VB Forum / General 2 / September 2004

I've had a look at the three jpg pictures on the link you posted. Two of
them have been cropped more or less correctly (although one is slighly out),
so that the circular image of the CD sits more or less exactly inside a
rectangle of similar size (within a few pixels or so). The third one ("The
Corrs") is slightly different because it has been cropped a bit too large
(in one dimension) so that the width of the rectangle is a bit larger than
the diameter of the circular image. However, for simplicity it might be best
for the time being to assume that most of your images will have been cropped
more or less correctly (as is approximately the case with the other two
pictures). If you want to write code to deal reliably with incorrectly
cropped images that might contain the circular portion anywhere within the
rectangle then I'm afraid you will have a lot of work on your hands writing
some reliable "edge detection" code. It's possible to do of course, but it
will be much simpler (at least for now) to assume that all of your images
will have been correctly cropped.

Before I start, I'd like to say that (as with most things) there is more
than one way of tackling this job, but for convenience I will use
(eventually!) the StretchBlt API to output the result to the printer. Not
all printers support StretchBlt, but I think most modern printers do. We can
easily use the GetDeviceCaps API to find out if the attached printer
supports StretchBlt, but I think I'll leave that for the time being.
Besides, as far as I know (but I'm not absolutely certain), the Windows
operating system will attempt to perform the "stretch" using some other
available lower level capability if confronted with a printer that does not
support it. Anyway, we'll leave complications of that nature until later
(much later!). Besides, if you just want the "unwanted pixels that surround
the circular image" to be printed white on the page (rather than
transparent) then you will be able to forget StretchBlt and use the more
simple VB PaintPicture method, which will look after all that stuff for you.
In fact (although I haven't thought too much about it yet) you will probably
be able to use VB PaintPicture method to perform a transparent "blit" as
well. But let's leave that for later.

The very first thing you need to do (whatever printer output method you end
up using) is to take your original jpg picture (any jpg picture will do for
test purposes) and turn it into a full colour bitmap (very easy to do if
your system is running at full colour depth, or even at 16 bit colour depth,
which I imagine applies to almost all computers these days). You can do this
simply by loading the jpg into a borderless Picture Box with its Autoredraw
property and its Autosize property both set to True. That will result in the
picture ending up as a bitmap in the Image property of the Picture Box. As
far as APIs are concerned, you can then access this bitmap using the hDC
property of the Picture Box. If you set the Form's ScaleMode to vbPixels
then the Width and Height properties of the Picture Box will tell you the
pixel size of the bitmap.

Then you need to create another Autoredraw borderless Picture Box of exactly
the same size as the first (after the picture has been loaded into it). In
this second Picture Box you need to draw a "mask" image. This "mask" needs
to contain black pixels wherever you want the original picture to remain in
their original state and white pixels where you want the original picture to
be turned white. In other words, to transform the rectangular bitmap into a
bitmap where the centre circle is "picture" and the surrounding area is
white you need to draw a mask that is a black circle on a white background.
If you also want to mask out the small central circular area then you need
to also draw a small white circle inside the large black circle.

Once you have done this, you need to combine every pixel in the bitmap with
the corresponding pixel in the mask using a logical OR operation. BitBlt
will do this for you if you set the dwRop parameter to vbSrcPaint. This will
result in the bitmap turning to white wherever there are white pixels in the
mask, and remaining its original colour wherever there are black pixels in
the mask. (I'm not sure how much you already know about bitwise logic, but
if you would like me to explain in detail why this happens then post again).

After doing all this you will end up with a cicular picture in the centre of
the Picture Box, with all surrounding pixels being white and with a small
white circle in the centre. If all you want to do is print this onto a blank
page then you can do it straight away, using either StretchBlt or
PaintPicture. However, if you do this, any "already drawn" stuff on the same
printer page will be overwritten by the entire rectangular picture
(including the white portions of it). If that's all you want to do then
that's fine. Otherwise, if you want to print it onto the page so that "the
white bits" are transparent (rather than white) and do not overwrite stuff
you have already drawn into that page then we have a little bit more work to
do (but I think I'll leave that for later).

Have a look at the following code. Obviously, you will need to substitute
the hard coded jpg picture path and filename with one that you have on your
own machine. It will of course work with quite large jpg pictures, but you
can more easily see what is happening if you use a small size jpg for test
purposes (perhaps about 400 pixels wide). The code automatically turns the
picture into an exact square, but it is obviously best if you start off by
using a jpg picture that is approximately square in the first place. All the
code does at the moment is load a jpg picture into a Picture Box, draw it
exactly square if it is not already so, draw an appropriate "circular" mask
and then combine the picture and ther mask as described above. It then draws
tyhe result to the printer at the correct size for a CD label. As I've
already said, if you want to take it one stage further than this and draw it
so that thw white portions are tran sparent (rather than white) so that they
don't interfere with anything else you have already sent to the printer on
the same page then there is a little more work to do (but not much though).
Post again if you would like help with that.

Paste the following code into a standard VB Form containing two Picture
Boxes and two Command Buttons.

Mike

Option Explicit
Private Declare Function BitBlt Lib "gdi32" _
 (ByVal hDestDC As Long, _
 ByVal x As Long, ByVal y As Long, _
 ByVal nWidth As Long, ByVal nHeight As Long, _
 ByVal hSrcDC As Long, _
 ByVal xSrc As Long, ByVal ySrc As Long, _
 ByVal dwRop As Long) As Long
Private picWide As Long, picHigh As Long

Private Sub Form_Load()
Me.WindowState = vbMaximized
Me.ScaleMode = vbPixels
With Picture1 ' the picture
 .AutoSize = True
 .BorderStyle = vbBSNone
 .ScaleMode = vbPixels
 .AutoRedraw = True
End With
With Picture2 ' the mask
 .BorderStyle = vbBSNone
 .ScaleMode = vbPixels
 .AutoRedraw = True
 .FillStyle = vbFSSolid
 .BackColor = vbWhite
End With
Command2.Enabled = False
End Sub

Private Sub Command1_Click()
Picture1.Picture = LoadPicture("c:\cd2.jpg")
DoEvents
picWide = Picture1.Width
picHigh = Picture1.Height
If picWide > picHigh Then
 Picture1.Height = picWide
 picHigh = picWide
Else
 Picture1.Width = picHigh
 picWide = picHigh
End If
Caption = picWide & " pixels by " & Format(picHigh) & " pixels."
Picture1.PaintPicture Picture1.Picture, 0, 0, picWide, picHigh
Picture1.Left = 0: Picture1.Top = 0
Picture2.Move picWide + 4, 0, picWide, picHigh
DoEvents
Picture2.FillColor = vbBlack
Picture2.Circle (picWide / 2, picHigh / 2), picWide \ 2 - 1, vbBlack
Picture2.FillColor = vbWhite
Picture2.Circle (picWide / 2, picHigh / 2), picWide \ 17, vbWhite
DoEvents
Command1.Enabled = False
Command2.Enabled = True
End Sub

Private Sub Command2_Click()
' This Blit combines the existing image in Picture1's
' Image property (the main picture) with the image data
' in Picture2's Image property (the mask image) using
' the vbSrcPaint raster opcode (a logical OR operation).
BitBlt Picture1.hDC, 0, 0, picWide, picHigh, _
 Picture2.hDC, 0, 0, vbSrcPaint
Picture1.Refresh ' copy the Autoredraw Image to the display
' Now print the resultant image at a diameter of 120 mm
Printer.ScaleMode = vbMillimeters
Printer.PaintPicture Picture1.Image, 0, 0, 120, 120
Printer.EndDoc
Command2.Enabled = False
Command1.Enabled = True
End Sub