[occt.git] / src / ImageUtility / ImageUtility.cxx

// Modified	27/12/98 : FMN ; PERF: OPTIMISATION LOADER (LOPTIM)
//

#include <Aspect_ColorRampColorMap.hxx>
#include <Standard_TypeMismatch.hxx>
#include <ImageUtility.ixx>


#define LOPTIM
#ifndef LOPTIM
static Handle(Aspect_ColorRampColorMap) TheBWColorMap = 
    new Aspect_ColorRampColorMap(0,2,Quantity_Color(1.,1.,1.,Quantity_TOC_RGB));
#else 
static Handle(Aspect_ColorRampColorMap)& _TheBWColorMap() {
    static Handle(Aspect_ColorRampColorMap) TheBWColorMap = 
	new Aspect_ColorRampColorMap(0,2,Quantity_Color(1.,1.,1.,Quantity_TOC_RGB));
return TheBWColorMap;
}
#define TheBWColorMap _TheBWColorMap()
#endif // LOPTIM


static void Rescale( const Handle(Image_PseudoColorImage) aPImage )

{ Aspect_IndexPixel PMin, PMax ;
  Standard_Integer dim, base ;
  Quantity_Color aColor ;
  Standard_Real scale, offset ; ;

  Handle(Aspect_ColorRampColorMap)::
	DownCast(aPImage->ColorMap())->ColorRampDefinition( base, dim, aColor );

  aPImage->Extrema( PMin, PMax ) ;

  if ( PMax.Value() == PMin.Value() ) return ;

  scale = Standard_Real( dim-1 ) / Standard_Real( PMax.Value() - PMin.Value()) ;
  offset = Standard_Real( base ) - Standard_Real( PMin.Value() ) * scale ;

  aPImage->Rescale( scale, offset ) ; 

}

Handle(Image_PseudoColorImage) ImageUtility::PixelColorDiff( 
		     const Handle(Image_Image)& Image1,
		     const Handle(Image_Image)& Image2 )
{ 
  return PixelColorDiff( Image1, Image2, TheBWColorMap ) ;
}

Handle(Image_PseudoColorImage) ImageUtility::PixelColorDiff( 
		const Handle(Image_Image)& Image1,
		const Handle(Image_Image)& Image2,
		const Handle(Aspect_ColorRampColorMap)& TheColorMap )

{ Handle(Image_PseudoColorImage) RetImage = NULL ;
  Standard_Integer x,y, Error, BasePixel, RampLength ;
  Standard_Integer LX, LY, UX, UY ;
  Standard_Integer LX1, LY1, UX1, UY1 ;
  Standard_Integer LX2, LY2, UX2, UY2 ;
  Aspect_IndexPixel aPixel;
  Standard_Real r1,g1,b1, r2,g2,b2 ;
  Quantity_Color aColor ;

  TheColorMap->ColorRampDefinition( BasePixel, RampLength, aColor ) ;

  Aspect_IndexPixel Pixel0(BasePixel);
  Aspect_IndexPixel Pixel1(BasePixel+RampLength-1);

  LX1 = Image1->LowerX() ; 
  LY1 = Image1->LowerY() ; 

  UX1 = Image1->UpperX() ; 
  UY1 = Image1->UpperY() ; 

  LX2 = Image2->LowerX() ; 
  LY2 = Image2->LowerY() ; 

  UX2 = Image2->UpperX() ; 
  UY2 = Image2->UpperY() ; 

  LX = Image1->LowerX() ; LX = Min( LX, Image2->LowerX() ) ;
  LY = Image1->LowerY() ; LY = Min( LY, Image2->LowerY() ) ;

  UX = Image1->UpperX() ; UX = Max( UX, Image2->UpperX() ) ;
  UY = Image1->UpperY() ; UY = Max( UY, Image2->UpperY() ) ;

  RetImage = new Image_PseudoColorImage( LX, LY, 
					 (UX-LX)+1, (UY-LY)+1, 
					TheColorMap, 
					Pixel1 ) ;

  if ( RampLength == 2 ) { //B&W ColorMap
	for ( y = LY ; y <= UY ; y++ ) {
	  for ( x = LX ; x <= UX ; x++ ) {
	    if ( ( x >= LX1 && x >= LX2 ) && ( x <= UX1 && x <= UX2 ) &&
	         ( y >= LY1 && y >= LY2 ) && ( y <= UY1 && y <= UY2 ) ) {
		if ( Image1->PixelColor(x,y) == Image2->PixelColor(x,y) ) {
		    RetImage->SetPixel( x,y, Pixel0 ) ;
		}
	    }
	  }
 	 }
  }
  else {
  	for ( y = LY ; y <= UY ; y++ ) {
	  for ( x = LX ; x <= UX ; x++ ) {
	    if ( ( x >= LX1 && x >= LX2 ) && ( x <= UX1 && x <= UX2 ) &&
		 ( y >= LY1 && y >= LY2 ) && ( y <= UY1 && y <= UY2 ) ) {
	      Image1->PixelColor(x,y).Values( r1,g1,b1, Quantity_TOC_RGB ) ;
	      Image2->PixelColor(x,y).Values( r2,g2,b2, Quantity_TOC_RGB ) ;

	      Error = BasePixel ;

	      Error += 
		Standard_Integer( (Abs(r1-r2)+Abs(g1-g2)+Abs(b1-b2))/3. 
					*(RampLength-1)
			        );

	      aPixel.SetValue( Error ) ;

	      RetImage->SetPixel( x,y, aPixel ) ;
	    }
	  }
  	}
	Rescale( RetImage ) ;
  }

  return RetImage ;
}

void ImageUtility::PixelColorDiff( 
		const Handle(Image_Image)& Image1,
		const Handle(Image_Image)& Image2,
		const Handle(Aspect_ColorRampColorMap)& TheColorMap,
		Handle(Image_PseudoColorImage)& RedDiff,
		Handle(Image_PseudoColorImage)& GreenDiff,
		Handle(Image_PseudoColorImage)& BlueDiff )

{ Standard_Integer x,y, Error, BasePixel, RampLength ;
  Standard_Integer LX, LY, UX, UY ;
  Standard_Integer LX1, LY1, UX1, UY1 ;
  Standard_Integer LX2, LY2, UX2, UY2 ;
  Aspect_IndexPixel aPixel;
  Standard_Real r1,g1,b1, r2,g2,b2 ;
  Quantity_Color aColor ;

  TheColorMap->ColorRampDefinition( BasePixel, RampLength, aColor ) ;

  Aspect_IndexPixel Pixel0(BasePixel);
  Aspect_IndexPixel Pixel1(BasePixel+RampLength-1);

  LX1 = Image1->LowerX() ; 
  LY1 = Image1->LowerY() ; 

  UX1 = Image1->UpperX() ; 
  UY1 = Image1->UpperY() ; 

  LX2 = Image2->LowerX() ; 
  LY2 = Image2->LowerY() ; 

  UX2 = Image2->UpperX() ; 
  UY2 = Image2->UpperY() ; 

  LX = Image1->LowerX() ; LX = Min( LX, Image2->LowerX() ) ;
  LY = Image1->LowerY() ; LY = Min( LY, Image2->LowerY() ) ;

  UX = Image1->UpperX() ; UX = Max( UX, Image2->UpperX() ) ;
  UY = Image1->UpperY() ; UY = Max( UY, Image2->UpperY() ) ;

  RedDiff = new Image_PseudoColorImage( LX, LY, 
					 (UX-LX)+1, (UY-LY)+1, 
					TheColorMap, 
					Pixel1 ) ;

  GreenDiff = new Image_PseudoColorImage( LX, LY, 
					 (UX-LX)+1, (UY-LY)+1, 
					TheColorMap, 
					Pixel1 ) ;

  BlueDiff = new Image_PseudoColorImage( LX, LY, 
					 (UX-LX)+1, (UY-LY)+1, 
					TheColorMap, 
					Pixel1 ) ;

  if ( RampLength == 2 ) { //B&W ColorMap
	for ( y = LY ; y <= UY ; y++ ) {
	  for ( x = LX ; x <= UX ; x++ ) {
	    if ( ( x >= LX1 && x >= LX2 ) && ( x <= UX1 && x <= UX2 ) &&
	         ( y >= LY1 && y >= LY2 ) && ( y <= UY1 && y <= UY2 ) ) {
	      Image1->PixelColor(x,y).Values( r1,g1,b1, Quantity_TOC_RGB ) ;
	      Image2->PixelColor(x,y).Values( r2,g2,b2, Quantity_TOC_RGB ) ;

	      if ( r1 == r2 ) RedDiff->SetPixel  ( x,y, Pixel0 ) ;
	      if ( g1 == g2 ) GreenDiff->SetPixel( x,y, Pixel0 ) ;
	      if ( b1 == b2 ) BlueDiff->SetPixel ( x,y, Pixel0 ) ;
	    }
	  }
 	 }
  }
  else {
  	for ( y = LY ; y <= UY ; y++ ) {
	  for ( x = LX ; x <= UX ; x++ ) {
	    if ( ( x >= LX1 && x >= LX2 ) && ( x <= UX1 && x <= UX2 ) &&
		  ( y >= LY1 && y >= LY2 ) && ( y <= UY1 && y <= UY2 ) ) {
	      Image1->PixelColor(x,y).Values( r1,g1,b1, Quantity_TOC_RGB ) ;
	      Image2->PixelColor(x,y).Values( r2,g2,b2, Quantity_TOC_RGB ) ;

	      Error = BasePixel + Standard_Integer( Abs(r1-r2)*(RampLength-1) );

	      aPixel.SetValue( Error ) ; RedDiff->SetPixel( x,y, aPixel ) ;

	      Error = BasePixel + Standard_Integer( Abs(g1-g2)*(RampLength-1) );

	      aPixel.SetValue( Error ) ; GreenDiff->SetPixel( x,y, aPixel ) ;

	      Error = BasePixel + Standard_Integer( Abs(b1-b2)*(RampLength-1) );

	      aPixel.SetValue( Error ) ; BlueDiff->SetPixel( x,y, aPixel ) ;
	    }
	  }
	}
	Rescale( RedDiff ) ;
	Rescale( GreenDiff ) ;
	Rescale( BlueDiff ) ;
  }
}
Commit	Line	Data
7fd59977	1	// Modified 27/12/98 : FMN ; PERF: OPTIMISATION LOADER (LOPTIM)
	2	//
	3
	4	#include <Aspect_ColorRampColorMap.hxx>
	5	#include <Standard_TypeMismatch.hxx>
	6	#include <ImageUtility.ixx>
	7
	8
	9	#define LOPTIM
	10	#ifndef LOPTIM
	11	static Handle(Aspect_ColorRampColorMap) TheBWColorMap =
	12	new Aspect_ColorRampColorMap(0,2,Quantity_Color(1.,1.,1.,Quantity_TOC_RGB));
	13	#else
	14	static Handle(Aspect_ColorRampColorMap)& _TheBWColorMap() {
	15	static Handle(Aspect_ColorRampColorMap) TheBWColorMap =
	16	new Aspect_ColorRampColorMap(0,2,Quantity_Color(1.,1.,1.,Quantity_TOC_RGB));
	17	return TheBWColorMap;
	18	}
	19	#define TheBWColorMap _TheBWColorMap()
	20	#endif // LOPTIM
	21
	22
	23	static void Rescale( const Handle(Image_PseudoColorImage) aPImage )
	24
	25	{ Aspect_IndexPixel PMin, PMax ;
	26	Standard_Integer dim, base ;
	27	Quantity_Color aColor ;
	28	Standard_Real scale, offset ; ;
	29
	30	Handle(Aspect_ColorRampColorMap)::
	31	DownCast(aPImage->ColorMap())->ColorRampDefinition( base, dim, aColor );
	32
	33	aPImage->Extrema( PMin, PMax ) ;
	34
	35	if ( PMax.Value() == PMin.Value() ) return ;
	36
	37	scale = Standard_Real( dim-1 ) / Standard_Real( PMax.Value() - PMin.Value()) ;
	38	offset = Standard_Real( base ) - Standard_Real( PMin.Value() ) * scale ;
	39
	40	aPImage->Rescale( scale, offset ) ;
	41
	42	}
	43
	44	Handle(Image_PseudoColorImage) ImageUtility::PixelColorDiff(
	45	const Handle(Image_Image)& Image1,
	46	const Handle(Image_Image)& Image2 )
	47	{
	48	return PixelColorDiff( Image1, Image2, TheBWColorMap ) ;
	49	}
	50
	51	Handle(Image_PseudoColorImage) ImageUtility::PixelColorDiff(
	52	const Handle(Image_Image)& Image1,
	53	const Handle(Image_Image)& Image2,
	54	const Handle(Aspect_ColorRampColorMap)& TheColorMap )
	55
	56	{ Handle(Image_PseudoColorImage) RetImage = NULL ;
	57	Standard_Integer x,y, Error, BasePixel, RampLength ;
	58	Standard_Integer LX, LY, UX, UY ;
	59	Standard_Integer LX1, LY1, UX1, UY1 ;
	60	Standard_Integer LX2, LY2, UX2, UY2 ;
	61	Aspect_IndexPixel aPixel;
	62	Standard_Real r1,g1,b1, r2,g2,b2 ;
	63	Quantity_Color aColor ;
	64
65	TheColorMap->ColorRampDefinition( BasePixel, RampLength, aColor ) ;
66
67	Aspect_IndexPixel Pixel0(BasePixel);
68	Aspect_IndexPixel Pixel1(BasePixel+RampLength-1);
69
70	LX1 = Image1->LowerX() ;
71	LY1 = Image1->LowerY() ;
72
73	UX1 = Image1->UpperX() ;
74	UY1 = Image1->UpperY() ;
75
76	LX2 = Image2->LowerX() ;
77	LY2 = Image2->LowerY() ;
78
79	UX2 = Image2->UpperX() ;
80	UY2 = Image2->UpperY() ;
81
82	LX = Image1->LowerX() ; LX = Min( LX, Image2->LowerX() ) ;
83	LY = Image1->LowerY() ; LY = Min( LY, Image2->LowerY() ) ;
84
85	UX = Image1->UpperX() ; UX = Max( UX, Image2->UpperX() ) ;
86	UY = Image1->UpperY() ; UY = Max( UY, Image2->UpperY() ) ;
87
88	RetImage = new Image_PseudoColorImage( LX, LY,
89	(UX-LX)+1, (UY-LY)+1,
90	TheColorMap,
91	Pixel1 ) ;
92
93	if ( RampLength == 2 ) { //B&W ColorMap
94	for ( y = LY ; y <= UY ; y++ ) {
95	for ( x = LX ; x <= UX ; x++ ) {
96	if ( ( x >= LX1 && x >= LX2 ) && ( x <= UX1 && x <= UX2 ) &&
97	( y >= LY1 && y >= LY2 ) && ( y <= UY1 && y <= UY2 ) ) {
98	if ( Image1->PixelColor(x,y) == Image2->PixelColor(x,y) ) {
99	RetImage->SetPixel( x,y, Pixel0 ) ;
100	}
101	}
102	}
103	}
104	}
105	else {
106	for ( y = LY ; y <= UY ; y++ ) {
107	for ( x = LX ; x <= UX ; x++ ) {
108	if ( ( x >= LX1 && x >= LX2 ) && ( x <= UX1 && x <= UX2 ) &&
109	( y >= LY1 && y >= LY2 ) && ( y <= UY1 && y <= UY2 ) ) {
110	Image1->PixelColor(x,y).Values( r1,g1,b1, Quantity_TOC_RGB ) ;
111	Image2->PixelColor(x,y).Values( r2,g2,b2, Quantity_TOC_RGB ) ;
112
113	Error = BasePixel ;
114
115	Error +=
116	Standard_Integer( (Abs(r1-r2)+Abs(g1-g2)+Abs(b1-b2))/3.
117	*(RampLength-1)
118	);
119
120	aPixel.SetValue( Error ) ;
121
122	RetImage->SetPixel( x,y, aPixel ) ;
123	}
124	}
125	}
126	Rescale( RetImage ) ;
127	}
128
129	return RetImage ;
130	}
131
132	void ImageUtility::PixelColorDiff(
133	const Handle(Image_Image)& Image1,
134	const Handle(Image_Image)& Image2,
135	const Handle(Aspect_ColorRampColorMap)& TheColorMap,
136	Handle(Image_PseudoColorImage)& RedDiff,
137	Handle(Image_PseudoColorImage)& GreenDiff,
138	Handle(Image_PseudoColorImage)& BlueDiff )
139
140	{ Standard_Integer x,y, Error, BasePixel, RampLength ;
141	Standard_Integer LX, LY, UX, UY ;
142	Standard_Integer LX1, LY1, UX1, UY1 ;
143	Standard_Integer LX2, LY2, UX2, UY2 ;
144	Aspect_IndexPixel aPixel;
145	Standard_Real r1,g1,b1, r2,g2,b2 ;
146	Quantity_Color aColor ;
147
148	TheColorMap->ColorRampDefinition( BasePixel, RampLength, aColor ) ;
149
150	Aspect_IndexPixel Pixel0(BasePixel);
151	Aspect_IndexPixel Pixel1(BasePixel+RampLength-1);
152
153	LX1 = Image1->LowerX() ;
154	LY1 = Image1->LowerY() ;
155
156	UX1 = Image1->UpperX() ;
157	UY1 = Image1->UpperY() ;
158
159	LX2 = Image2->LowerX() ;
160	LY2 = Image2->LowerY() ;
161
162	UX2 = Image2->UpperX() ;
163	UY2 = Image2->UpperY() ;
164
165	LX = Image1->LowerX() ; LX = Min( LX, Image2->LowerX() ) ;
166	LY = Image1->LowerY() ; LY = Min( LY, Image2->LowerY() ) ;
167
168	UX = Image1->UpperX() ; UX = Max( UX, Image2->UpperX() ) ;
169	UY = Image1->UpperY() ; UY = Max( UY, Image2->UpperY() ) ;
170
171	RedDiff = new Image_PseudoColorImage( LX, LY,
172	(UX-LX)+1, (UY-LY)+1,
173	TheColorMap,
174	Pixel1 ) ;
175
176	GreenDiff = new Image_PseudoColorImage( LX, LY,
177	(UX-LX)+1, (UY-LY)+1,
178	TheColorMap,
179	Pixel1 ) ;
180
181	BlueDiff = new Image_PseudoColorImage( LX, LY,
182	(UX-LX)+1, (UY-LY)+1,
183	TheColorMap,
184	Pixel1 ) ;
185
186	if ( RampLength == 2 ) { //B&W ColorMap
187	for ( y = LY ; y <= UY ; y++ ) {
188	for ( x = LX ; x <= UX ; x++ ) {
189	if ( ( x >= LX1 && x >= LX2 ) && ( x <= UX1 && x <= UX2 ) &&
190	( y >= LY1 && y >= LY2 ) && ( y <= UY1 && y <= UY2 ) ) {
191	Image1->PixelColor(x,y).Values( r1,g1,b1, Quantity_TOC_RGB ) ;
192	Image2->PixelColor(x,y).Values( r2,g2,b2, Quantity_TOC_RGB ) ;
193
194	if ( r1 == r2 ) RedDiff->SetPixel ( x,y, Pixel0 ) ;
195	if ( g1 == g2 ) GreenDiff->SetPixel( x,y, Pixel0 ) ;
196	if ( b1 == b2 ) BlueDiff->SetPixel ( x,y, Pixel0 ) ;
197	}
198	}
199	}
200	}
201	else {
202	for ( y = LY ; y <= UY ; y++ ) {
203	for ( x = LX ; x <= UX ; x++ ) {
204	if ( ( x >= LX1 && x >= LX2 ) && ( x <= UX1 && x <= UX2 ) &&
205	( y >= LY1 && y >= LY2 ) && ( y <= UY1 && y <= UY2 ) ) {
206	Image1->PixelColor(x,y).Values( r1,g1,b1, Quantity_TOC_RGB ) ;
207	Image2->PixelColor(x,y).Values( r2,g2,b2, Quantity_TOC_RGB ) ;
208
209	Error = BasePixel + Standard_Integer( Abs(r1-r2)*(RampLength-1) );
210
211	aPixel.SetValue( Error ) ; RedDiff->SetPixel( x,y, aPixel ) ;
212
213	Error = BasePixel + Standard_Integer( Abs(g1-g2)*(RampLength-1) );
214
215	aPixel.SetValue( Error ) ; GreenDiff->SetPixel( x,y, aPixel ) ;
216
217	Error = BasePixel + Standard_Integer( Abs(b1-b2)*(RampLength-1) );
218
219	aPixel.SetValue( Error ) ; BlueDiff->SetPixel( x,y, aPixel ) ;
220	}
221	}
222	}
223	Rescale( RedDiff ) ;
224	Rescale( GreenDiff ) ;
225	Rescale( BlueDiff ) ;
226	}
227	}