Farben eines Bitmaps manipulieren

[Jan]

Hallo,

gibt es die Möglichkeit, "ganz einfach" die angezeigten Farben eines Bitmaps unter XbpBitmap zu verändern? Mit geht es ausschließlich darum, die Anzeige in Graustufen zu ermöglichen. Das Bitmap selber soll unverändert bleiben.

Jan

[UliTs]

Hallo Jan,

ich geh davon aus, daß es sich bei Dir um 8-bit-Bitmaps handelt,
das heißt, die Instanzvariable :bits hat den Wert 8.
Unter XbpBitmap() gibt es die Methode :getColorTable().
Damit kannst Du die aktuelle Farbtabelle des Bitmaps einlesen.
In der Hilfe ist die Tabelle beschrieben.
Für Grauwertdarstellung müssen die RGB-Werte ja für jede
Farbe gleich sein. Initialisiere eine Grauwerttabelle:

Code: Alles auswählen

{ {0,0,0},{1,1,1},{2,2,2},... }

mittels Schleife:

Code: Alles auswählen

LOCAL aGrauwerttabelle[256]
FOR I=0 TO 255
  aGrauwerttabelle[I+1] = { I,I,I }
NEXT I

und kopiere sie in den entsprechenden Presentation Space mittels

Code: Alles auswählen

oXbpBitmap:setColorIndex(aGrauwerttabelle)

Ich hoffe, dies funktioniert wunschgemäß.

Uli

[Jan]

Hallo Uli,

leider funktioniert das garnicht.

SetColorIndex ist ausschließlich für XbpPresSpace da. Und auch das Array ist komplett falsch.

Ich habe dann mal wirklich den XbpPresSpace versucht zu bearbeiten, indem ich da eine Schleife drauf eingebaut habe, das die Farbarrays manipuliert. Das könnte in dem bestimmten Fall schon passen. Aber das funktionierte leider auch nicht.

Ich habe einfach das Problem, aus einer Farbe den dazugehörigen Grauwert zu ermitteln.

Für Drucker habe ich eine passende Vorgehensweise gefunden, wodurch farbige Ausdrucke auf schwarzweiß umgemünzt werden. Funktioniert aber auch nur bei Drucker-Objekten.

Jan

[brandelh]

Hallo Jan,

machst du das in XbpBitmap, oder druckst du lediglich ein farbiges Bitmap auf den S/W-Drucker?

Im letzten Fall macht dann XBase++ gar nichts. Normalerweise setzt der Druckertreiber Farbinfos nach Graustufen um, wenn farbige Druckaufträge an ein S/W-Drucker gesendet werden.

Das BMP Format soll aber einfach aufgebaut sein.
Wenn du weißt (ich weiß es nicht !), welche Bits (z.B. immer das 4Byte, 16 Bit lang...) Farbe beinhalten und du daraus graustufen machen willst, tausche diese doch im Speicher um und speichere eventuell in einer temporären Datei - falls das nötig ist.

Hierzu könnten die lowlevel Filefunktionen dienlich sein (kopie anlegen), oder mit memoread einlesen und mit fcreate... speichern.
MEMOWRIT() geht nicht, dadort noch ein chr(26) oder 27 angehängt wird...

Auf Wickipedia oder anderen Internetseiten wird das genau BMP Format bestimmt erklärt.

[AUGE_OHR]

hi,

gibt es die Möglichkeit, "ganz einfach" die angezeigten Farben eines Bitmaps unter XbpBitmap zu verändern? Mit geht es ausschließlich darum, die Anzeige in Graustufen zu ermöglichen. Das Bitmap selber soll unverändert bleiben.

grundsätzlich sollte es mit GraBitBlt gehen. Auch der Ansatz mit 8 bit
scheint richtig ...

hier etwas was dir vielleicht weiter hilft :

Code: Alles auswählen

DLLFUNCTION SetPixelV( hdc, x, y, crColor ) USING STDCALL FROM GDI32.DLL
DLLFUNCTION GetPixel( hdc, x, y ) USING STDCALL FROM GDI32.DLL
DLLFUNCTION GetWindowDC( hwnd ) USING STDCALL FROM USER32.DLL

***** Syntax: ImageManip(....)
* oBmp      The Static containing the Bitmap, Pass by Reference
* oDa       The Drawing Area object
* aBmpPos   The Position of oBmp on oDa, Pass by Reference
* aBmpSize  The Size of the Bmp Static, Pass by Reference
***********************************************************

NegImage(@oBmp,oDa, @aBmpPos, @aBmpSize)

FUNCTION NegImage(oXbp, oDa, aBmpPos, aSize)
*******************************************************************************
LOCAL oBitmap
LOCAL oTargetPS
LOCAL aPos := aBmpPos
LOCAL aSourceRect[4]
LOCAL aTargetRect
LOCAL nHDC  := GetWindowDC(oXbp:getHWND())
LOCAL nHi   := aSize[2]
LOCAL nWd   := aSize[1]
LOCAL nX
LOCAL nY
LOCAL oPS
LOCAL oXbpBitmap

For nX := 0 To nWd
   For nY := 0 To nHi
      SetPixelV( nHDC, nX,nY, NegRGBVal(GetPixel(nHDC, nX, nY)))
   Next nY
Next nX

***** Make Image Persistent

oPS            := oDa:lockPS()

oBitmap        := XbpBitmap():new():create( oPS )

oTargetPS      := XbpPresSpace():new():create()

aSourceRect[1] := aSourceRect[3] := aPos[1]
aSourceRect[2] := aSourceRect[4] := aPos[2]
aSourceRect[3] += aSize[1]
aSourceRect[4] += aSize[2]

aTargetRect    := {0, 0, aSize[1], aSize[2]}

oBitmap:presSpace( oTargetPS )
oBitmap:make( aSize[1], aSize[2] )
GraBitBlt( oTargetPS, oPS, aTargetRect, aSourceRect )

oDa:UnlockPS( oPS )

oXbp:setcaption( oBitmap )

RETURN oXbp

************************************************************
*
*                      FUNCTION NegRGBVal()
*
*  nValue = an RGB composite value, with or without a 0x1000000 mask.
*
*  (This is used in a program where a colour value is calculated and can
*  result in a negative value so the Abs() is taken.)
*
*************************************************************
FUNCTION NegRGBVal(nColor)
   LOCAL nR,nG,nB := 0

   ***** Allow for no argument.
   ***** Validate range
   nColor:= IIF( nColor == nil,  0, INT( Abs( nColor % 16777216 ) ) )

      nB  := 255 - INT( nColor / 65536 )
      nG  := 255 - INT((nColor % 65536 ) / 256 )
      nR  := 255 - INT( nColor % 256 )

RETURN Int( nR+ (nG*256) + (nB*65536) )
*                     END FUNCTION NegRGBVal()
******************************************************

gruss by OHR
Jimmy

[Günter Beyes]

Hallo Jan,

probier mal diese Funktion.
Die verwendete Graustufenformel ist zweifelsohne für manche Zwecke zu simpel, vielleicht hilft es aber doch weiter.

Günter

Code: Alles auswählen

#INCLUDE "common.CH"
#INCLUDE "xbp.CH"

FUNCTION BmpGreyscale( oBmpIn, lNeu )

LOCAL oBmpOut
LOCAL oPS
LOCAL cColorTable
LOCAL nBits         := oBmpIn:bits
LOCAL cBuffer       := oBmpIn:setBuffer()
LOCAL nBufferOffset := oBmpIn:bufferOffset
LOCAL nXSize        := oBmpIn:xSize
LOCAL nYSize        := oBmpIn:ySize

DEFAULT lNeu TO TRUE

IF nBits = 24
   /*
   True-color-Bitmap.
   Die Intensität der Grundfarben rot, grün und blau 
   ist für jedes Pixel separat angeben.
   (Je Grundfarbe 1 Byte: Wert 0 = nicht verwendet; 255 = Maximum).
   
   Die Tabelle der Pixelfarben beginnt bei oBitmap:bufferOffset.
   Die Zahl der Einträge (Zahl der Pixel) 
   ist gleich oBitmap:xSize * oBitmap:ySize.
   
   Um an der Farbe zu drehen, muß man die Pixeltabelle direkt bearbeiten.
   */
   
   PixelTableGreyscale( @cBuffer, nBufferOffset, nXSize * nYSize )

ELSEIF nBits >= 1 .AND. nBits < 24

   /*
   Ansonsten existiert eine Farbtabelle; die Pixeltabelle stellt lediglich 
   die Zuordnung Pixel -> Farbtabellenindex her.
   
   Um an der Farbe zu drehen, muß man die Farbtabelle bearbeiten.
   
   Leider gibt's keine XbpBitmap-Methode :setColorTable(),
   deshalb führt kein Weg daran vorbei, die geänderte Farbtabelle "zu Fuß" 
   zusammenzubauen und dann in den Bitmap-Puffer einzufügen.
   Siehe dazu auch die Stichworte BITMAPINFO und BITMAPINFOHEADER 
   in Microsofts Plattform-SDK oder MSDN.
   */
   
   ColorTableGreyscale( @cColorTable, oBmpIn:getColorTable() )

   IF cColorTable <> NIL
      /*
      Den geänderten Bitmap-Puffer zusammenbauen.
      Die ersten vier Bytes enthalten die Länge der BITMAPINFOHEADER-Struktur,
	  gefolgt vom Rest der Struktur.
      Es folgt die Farbtabelle. Sie erstreckt sich bis nBufferOffset (inklusive).
      Ab nBufferOffset+1 kommt schließlich die Zuordnungstabelle 
	  Pixel -> Farbtabellenindex.
      */
      
	  cBuffer := left( cBuffer, Bin2U( substr(cBuffer,1,4) ) ) + ;
                 cColorTable + ;
                 substr( cBuffer, nBufferOffset+1 )

   ENDIF
ENDIF

IF lNeu
   /*
   Ein neues Bitmap-Objekt erzeugen
   (in diesem Fall zur Anzeige am Bildschirm)
   */
   
   oPS  := AppDesktop():LockPS()

   oBmpOut := XbpBitmap():New():Create( oPS )

   oBmpOut:Make( nXSize, nYSize, 1, nBits )
   oBmpOut:setBuffer( cBuffer, XBPBMP_FORMAT_WIN3X )

   AppDesktop():UnlockPS( oPS )
ELSE
   // das vorgegebene Bitmap-Objekt ändern	
   oBmpOut := oBmpIn
   oBmpOut:setBuffer( cBuffer, XBPBMP_FORMAT_WIN3X )
ENDIF

RETURN oBmpOut

******************************************************************************
// cBuffer muß "by reference" übergeben werden

STATIC PROCEDURE PixelTableGreyscale( cBuffer,;
	nBufferOffset, nBitmapPixels )

LOCAL i, nBufferIndex, cGrau

FOR i := 1 TO nBitmapPixels
   /*
   Die Pixeldaten beginnen bei nBufferOffset+1.

   Bei 24-Bit-Truecolor-Bitmaps belegt jedes Pixel drei Byte im Puffer.
   Farbfolge: B, G, R.

   R, G und B jedes Pixels durch den Grauwert ersetzen.

   Grauwert := 0.299 * rot + 0.587 * grün + 0.114 * blau

   Diese Transformationsgleichung kommt aus der Fernsehtechnik 
   und wird dort verwendet, um Farbbilder in Schwarzweiß
   darzustellen.
	
   Es sind 255 verschiedene Graustufen möglich, von
   0 (schwarz) bis 255 (weiß).
 
   Wenn man die Zahl der Graustufen reduziert, z.B. auf 64,
   sieht das Ergebnis unter Umständen besser aus, aber
   das kostet Rechenzeit.
   
   */

   nBufferIndex := nBufferOffset+1 + (i-1)*3

   cGrau := chr( max( 0.114 * asc( cBuffer[ nBufferIndex ] ) + ;	// B
                      0.587 * asc( cBuffer[ nBufferIndex+1 ] ) + ;  // G
			          0.299 * asc( cBuffer[ nBufferIndex+2 ] ) , ;  // R
				      255 ) )
   
   cBuffer[ nBufferIndex ]   := cGrau
   cBuffer[ nBufferIndex+1 ] := cGrau
   cBuffer[ nBufferIndex+2 ] := cGrau

NEXT

RETURN

******************************************************************************
// cColorTable muß "by reference" übergeben werden

STATIC PROCEDURE ColorTableGreyscale( cColorTable, aColorTable )
LOCAL nColors := len( aColorTable )
LOCAL i, nBufferIndex, cGrau

   /*
   Jeder Eintrag in der Bitmap-internen Farbtabelle belegt vier Bytes. 
   Drei davon sind die RGB-Werte; der vierte 
   ist für Alpha-Transparenz reserviert.
   */
   cColorTable := replicate( chr(0), 4*nColors )

   FOR i := 1 TO nColors
       nBufferIndex := (i-1)*4 + 1
	   cGrau := chr( max( 0.114 * asc( aColorTable[i,3] ) + ; // B
	                      0.587 * asc( aColorTable[i,2] ) + ; // G
				          0.299 * asc( aColorTable[i,1] ) , ; // R
					      255 ) )

       cColorTable[nBufferIndex]   := cGrau // B
       cColorTable[nBufferIndex+1] := cGrau // G
       cColorTable[nBufferIndex+2] := cGrau // R
   NEXT

RETURN

[AUGE_OHR]

hi,

siehe dir mal im "public.xbase++.gui" vom "Klemens Lichter" vom
24.11.2004 an (BMPcolor)

Paulo,
seeing that Günther already posted a solution, you're
probably all set already. Still, I decided TO post my
suggestion anyway. You never know...

Notes:
o Code assumes source image IN XbpBitmap object
"oBmp"
o Destination image IS transferred into PS
"oTargetPS", which may be a Micro PS
obtained via ":lockPS()"
o Code looks AS IF it doesn't clean up
at all when done
o Can't remember anything else, except:
did it ever work <giggle>?

Code: Alles auswählen

   /*
   ** Create the destination bitmap object;
   ** note that we'll explicitly request a
   ** format with a Color table; currently
   ** 256 shades of gray.

   oTgtBitmap := XbpBitmap():new():create( oPS )
   oTargetPS :=XbpPresSpace():new():create()
   oTgtBitmap:presSpace( oTargetPS )
   oTgtBitmap:make( oBMP:xSize, oBMP:ySize, oBMP:Planes, 8 )

   FOR i := 0 TO 255
      aRGB := Array( 3 )
      aRGB[1] := i
      aRGB[2] := i
      aRGB[3] := i

      AAdd( aColorTable, aRGB )
   NEXT

    oTargetPS:setColorIndex( 0, aColorTable )

   // Render the source into the destination bitmap;
   // this implicitly maps the source bitmap's color
   // to the colors just defined
   oBMP:draw( oTargetPS, {0,0})

--
Regards,
Till Warweg
[Alaska Software]

gruss by OHR
Jimmy

[Jan]

@ Hubert: Ich möchte wirklich nur das Bitmap in Graustufen auf dem Monitor ausgeben.

@ Jimmy: Den Beitrag von Till habe ich auch inzwischen gefunden. Schön kurz und einfach. Funktioniert aber nicht sauber, da bekomme ich einfach nur einen schwarzen Klecks raus.

@ Günter: Ich habe mal Dein Beispiel übernommen, weil das Xbase pur ist, ohne Systemaufrufe. Gibt aber immer einen Parameterfehler in der fast letzten Zeile mit den 3 ASC(). Da bin ich noch am Testen, wo da der Fehler liegt.

@ All: Danke für Eure Mühen, teilweise sind da ja ziemlich aufwändige Codebeispiele bei rausgekommen.

Jan

[Jan]

Günter,

so, der Fehler ist gefunden. Das Array gibt einen numerischen Wert zurück. Und ASC() mag nur Strings. Also habe ich das umgestrickt auf ASC(STR()). Dann gibt es wenigstens keine Fehlermeldung mehr.

Aber das Ergebnis ist ähnlich wie bei dem Beispiel von Till. Bei ihm erhalte ich einen schwarzen Klecks, bei Dir einen weißen.

Jan

[Günter Beyes]

Hallo Jan,

Dies hat zwar kaum mit dem Parameterfehler zu tun, aber dummerweise habe ich die Funktion beim Übersetzen der Kommentare und Überarbeiten katastrophal verschlimmbessert.

An zwei Stellen wird die Funktion max() aufgerufen. Bitte ersetze beide Aufrufe durch min(). Max() würde einen weißen Klecks erzeugen. :(

Kann ich eigentlich meine Nachrichten nach dem Absenden editieren? Das wäre so ein Fall dafür...

Was den Parameterfehler betrifft, wäre ich gern behilflich. Welche Xbase++-Version benutzt Du, und was sagt das Error-Objekt im einzelnen?

Günter

[Jan]

Hallo Günter,

ja, editieren geht. Links oben am Rand von Deinem Beitrag ist eine kleine Schaltfläche dafür.

Und MIN() statt MAX() hat auch nicht viel gebracht, jetzt ist alles dunkelgrau.

Ich arbeite mit 1.9. Und der Fehler lautet "Base/3 Parameter hat falschen Typ"

Jan

[Martin Altmann]

Hallo Jan,
ich meine, in einem ähnlichen Problemfall gelesen zu haben, dass die Ursprungsgrafik nicht "richtig" war - also dem "echten" Standard nicht entsprach!
Es gibt wohl die Möglichkeit, die Farbpalette in der Grafik auf zwei verschiedenen Arten zu speichern - einmal auf der richtigen und dokumentierten, und einmal falsch.
Ein gutes Grafikprogramm kommt mit beidem zurecht - Xbase++ wohl nicht.
Nimm doch mal eine andere Grafik, die Du mit einem anderen Programm erstellt hast und probier es damit!?

Viele Grüße,
Martin

[Jan]

Martin,

ja, das kann wohl sein. Ich habe mal eine neue Grafik erstellt, damit funktioniert das wohl einwandfrei.

Hat das mal jemand an Alaska gemeldet?

Jan

[Martin Altmann]

Hallo Jan,
da kann wohl Alaska nicht wirklich was für, oder?
Aber Du kannst ja Steffen am 4.11. gerne drauf ansprechen - kostet Dich dann keine DSP-Punkte!

Viele Grüße,
Martin

[Martin Altmann]

Hallo Jan,
ich habe nochmals in der Newsgroup gewühlt und folgenden Workaround von Till Warweg gefunden - probiere es mal damit:

______________________ snip _________________________

...

Code: Alles auswählen

oBmp:= XbpBitmap():New():Create()

oBmp:LoadFile( ... )

// Work-around for PNG: Set foreground and // background colors for 
monochrome images.

// Shouldn't be harmful for other image // formats.

IF( ::oBitmap:Bits == 1 )

SetDefMonoColors( oBmp )

ENDIF

...



FUNCTION SetDefMonoColors( oBmp )

IF ValType(oBmp) != "O" .OR. oBmp:Bits > 1

RETURN .F.

ENDIF

oPS := XbpPresspace():New():Create()

::oBitmap:Presspace( oPS )

oPS:SetColorIndex( 0, {0,0,0} )

oPS:SetColorIndex( 1, {255,255,255} )


oPS:Destroy()

RETURN .T.

Viele Grüße,
Martin

[Jan]

Hallo Martin,

bis jetzt habe ich noch keinen einzigen DSP gekauft. Und dafür würde ich bestimmt auch keinen opfern

Warum soll Alaska denn da nichts für können? Nun, fehlerhaften Bitmaps kann das sicher nicht deren Problem sein. Aber wenn "normale" Grafikprogramme damit umgehen können, warum könnte man das nicht in Xbase implementieren? Es ist doch so: Wird etwas falsch angezeigt, schiebt man den schwarzen Peter erstmal den 3 von Alaska in die Schuhe. Ob die was dafür können oder nicht.

Und der Code von Günter funktioniert doch nicht so ganz, das ganze Bitmap wird streifig. Graustufige Streifen.

Jan

[Martin Altmann]

Hallo Jan,
hat Dir denn der Workaround von Till, den ich kurz vorher gepostet habe, geholfen?

Viele Grüße,
Martin

[Martin Altmann]

Hallo Jan,
sollte der Workaround von Till nicht funktionieren, musst Du Deine "fehlerhaften" Grafiken in "richtige" konvertieren.
Dazu öffnest Du eine "falsche" Grafik einfach in dem Grafikprogramm, in dem Du Deine "richtige" von vorhin erstellt hattest und speicherst sie wieder unter einem neuen Namen (damit wirklich alles neu rausgeschrieben wird!).
Dann versuchst Du es mit dieser neuen - klappt es, bennenst Du sie so um, wie sie vorher auch hieß, und machst mit der nächsten weiter...

Viele Grüße,
Martin

[Jan]

Hallo Martin,

aber der Workaround von Till gilt nur für png? Oder verstehe ich die Kommentare zum Code falsch?

Ich habe bereits mit MS-Paint eine komplett neue bmp erstellt. Da habe ich nach der Konvertierung mit Günters korrigierten Code zwar Graustufen drin, aber jede 2. Zeile ist dunkler. Deswegen mein Kommentar mit den Streifen.

Ich werd jetzt doch mal Jimmys Beispiel versuchen, und dann noch mal Tills mit meiner eigenen bmp. Irgendwie muß das doch hinzubekommen sein!

Jan

[Jan]

Hallo Jimmy,

leider steigt Dein Code in dieser Zeile aus

Code: Alles auswählen

LOCAL nHDC  := GetWindowDC(oXbp:getHWND())

"Methode ist für dieses Objekt unbekannt"

Jan

[AUGE_OHR]

hi,

leider steigt Dein Code in dieser Zeile aus

Code: Alles auswählen

LOCAL nHDC  := GetWindowDC(oXbp:getHWND())

"Methode ist für dieses Objekt unbekannt"

sind die DLLFUNCTION sowie #include DLL.CH eingebunden ?

gruss by OHR
Jimmy

[Jan]

Hallo Jimmy,

ohne dll.ch würde bei das kompilieren nicht funktionieren (hohes Warnlevel). Und die DLL-Funktionen sind auch drin. Es gibt keine bestimmte Position, wo die hin müssen, oder?

Jan

[brandelh]

Hi,

also laut Handbuch ist getHWND() eine Methode von XbpWindow().
XbpBitmap() ist davon nicht abgeleitet und hat auch diese Mehtode nicht.
Das Problem liegt also nicht im DLLFunktion Aufruf, sondern im ermitteln des Fensterhandles.

Ist eventuell der Presentationspace von XbpBitmap() anzugeben ?
- dieser hätte ja ein device, ob aber auch bei XbpBitmap() ???
- laut Beschreibung XbpPresSpace() enthält er Infos über
- Farben vor und Hintergrund
- Farbmischattribute ... eventuell könnte man hier ansetzen ...

[Jan]

Hallo Hubert,

nun, mit dem PS habe ich das auch schon versucht. Gleiches Ergebnis.

Merkwürdig. Ich dachte nicht, daß das so kompliziert ist. 3 gestandene Programmierer beißen sich an so einer Sache die Zähne aus, obwohl jeder einen anderen Ansatz nimmt. Das hab ich auch noch nicht erlebt.

Jan

[brandelh]

Ich dachte nicht, daß das so kompliziert ist...

mit dem 'richtigen' Controll, wäre das eine Kleinigkeit :ShowMonocrome() leider haben wir das nicht standardmäßig. Eventuell gibt es ja sowas als ActiveX ?