KiCad PCB EDA Suite
BITMAPCONV_INFO Class Reference

#include <bitmap2component.h>

Public Member Functions

 BITMAPCONV_INFO (std::string &aData)
 
int ConvertBitmap (potrace_bitmap_t *aPotrace_bitmap, OUTPUT_FMT_ID aFormat, int aDpi_X, int aDpi_Y, BMP2CMP_MOD_LAYER aModLayer)
 Run the conversion of the bitmap. More...
 
std::string & GetErrorMessages ()
 

Private Member Functions

void createOutputData (BMP2CMP_MOD_LAYER aModLayer=(BMP2CMP_MOD_LAYER) 0)
 Creates the data specified by m_Format. More...
 
void outputDataHeader (const char *aBrdLayerName)
 Function outputDataHeader write to file the header depending on file format. More...
 
void outputDataEnd ()
 Function outputDataEnd write to file the last strings depending on file format. More...
 
const char * getBoardLayerName (BMP2CMP_MOD_LAYER aChoice)
 
void outputOnePolygon (SHAPE_LINE_CHAIN &aPolygon, const char *aBrdLayerName)
 Function outputOnePolygon write one polygon to output file. More...
 

Private Attributes

enum OUTPUT_FMT_ID m_Format
 
int m_PixmapWidth
 
int m_PixmapHeight
 
double m_ScaleX
 
double m_ScaleY
 
potrace_path_t * m_Paths
 
std::string m_CmpName
 
std::string & m_Data
 
std::string m_errors
 

Detailed Description

Definition at line 54 of file bitmap2component.h.

Constructor & Destructor Documentation

◆ BITMAPCONV_INFO()

BITMAPCONV_INFO::BITMAPCONV_INFO ( std::string &  aData)

Definition at line 61 of file bitmap2component.cpp.

61  :
62  m_Data( aData )
63 {
65  m_PixmapWidth = 0;
66  m_PixmapHeight = 0;
67  m_ScaleX = 1.0;
68  m_ScaleY = 1.0;
69  m_Paths = NULL;
70  m_CmpName = "LOGO";
71 }
std::string m_CmpName
potrace_path_t * m_Paths
enum OUTPUT_FMT_ID m_Format
#define NULL
std::string & m_Data

References m_CmpName, m_Format, m_Paths, m_PixmapHeight, m_PixmapWidth, m_ScaleX, m_ScaleY, NULL, and POSTSCRIPT_FMT.

Member Function Documentation

◆ ConvertBitmap()

int BITMAPCONV_INFO::ConvertBitmap ( potrace_bitmap_t *  aPotrace_bitmap,
OUTPUT_FMT_ID  aFormat,
int  aDpi_X,
int  aDpi_Y,
BMP2CMP_MOD_LAYER  aModLayer 
)

Run the conversion of the bitmap.

Definition at line 74 of file bitmap2component.cpp.

77 {
78  potrace_param_t* param;
79  potrace_state_t* st;
80 
81  // set tracing parameters, starting from defaults
82  param = potrace_param_default();
83 
84  if( !param )
85  {
86  char msg[256];
87  sprintf( msg, "Error allocating parameters: %s\n", strerror( errno ) );
88  m_errors += msg;
89  return 1;
90  }
91 
92  // For parameters: see http://potrace.sourceforge.net/potracelib.pdf
93  param->turdsize = 0; // area (in pixels) of largest path to be ignored.
94  // Potrace default is 2
95  param->opttolerance = 0.2; // curve optimization tolerance. Potrace default is 0.2
96 
97  /* convert the bitmap to curves */
98  st = potrace_trace( param, aPotrace_bitmap );
99 
100  if( !st || st->status != POTRACE_STATUS_OK )
101  {
102  if( st )
103  {
104  potrace_state_free( st );
105  }
106  potrace_param_free( param );
107 
108  char msg[256];
109  sprintf( msg, "Error tracing bitmap: %s\n", strerror( errno ) );
110  m_errors += msg;
111  return 1;
112  }
113 
114  m_PixmapWidth = aPotrace_bitmap->w;
115  m_PixmapHeight = aPotrace_bitmap->h; // the bitmap size in pixels
116  m_Paths = st->plist;
117 
118  switch( aFormat )
119  {
120  case KICAD_LOGO:
122  m_ScaleX = PL_IU_PER_MM * 25.4 / aDpi_X; // the conversion scale from PPI to micron
123  m_ScaleY = PL_IU_PER_MM * 25.4 / aDpi_Y; // Y axis is top to bottom
125  break;
126 
127  case POSTSCRIPT_FMT:
129  m_ScaleX = 1.0; // the conversion scale
130  m_ScaleY = m_ScaleX;
131  // output vector data, e.g. as a rudimentary EPS file (mainly for tests)
133  break;
134 
135  case EESCHEMA_FMT:
137  m_ScaleX = 1000.0 / aDpi_X; // the conversion scale from PPI to legacy IU (mil)
138  m_ScaleY = -1000.0 / aDpi_Y; // Y axis is bottom to Top for components in libs
140  break;
141 
142  case PCBNEW_KICAD_MOD:
144  m_ScaleX = PCB_IU_PER_MM * 25.4 / aDpi_X; // the conversion scale from PPI to IU
145  m_ScaleY = PCB_IU_PER_MM * 25.4 / aDpi_Y; // Y axis is top to bottom in Footprint Editor
146  createOutputData( aModLayer );
147  break;
148 
149  default:
150  break;
151  }
152 
153 
154  bm_free( aPotrace_bitmap );
155  potrace_state_free( st );
156  potrace_param_free( param );
157 
158  return 0;
159 }
potrace_path_t * m_Paths
static void bm_free(potrace_bitmap_t *bm)
void createOutputData(BMP2CMP_MOD_LAYER aModLayer=(BMP2CMP_MOD_LAYER) 0)
Creates the data specified by m_Format.
enum OUTPUT_FMT_ID m_Format
constexpr double PCB_IU_PER_MM
std::string m_errors
constexpr double PL_IU_PER_MM

References bm_free(), createOutputData(), EESCHEMA_FMT, KICAD_LOGO, m_errors, m_Format, m_Paths, m_PixmapHeight, m_PixmapWidth, m_ScaleX, m_ScaleY, PCB_IU_PER_MM, PCBNEW_KICAD_MOD, PL_IU_PER_MM, and POSTSCRIPT_FMT.

Referenced by BM2CMP_FRAME::ExportToBuffer().

◆ createOutputData()

void BITMAPCONV_INFO::createOutputData ( BMP2CMP_MOD_LAYER  aModLayer = (BMP2CMP_MOD_LAYER) 0)
private

Creates the data specified by m_Format.

Definition at line 389 of file bitmap2component.cpp.

390 {
391  std::vector <potrace_dpoint_t> cornersBuffer;
392 
393  // polyset_areas is a set of polygon to draw
394  SHAPE_POLY_SET polyset_areas;
395 
396  // polyset_holes is the set of holes inside polyset_areas outlines
397  SHAPE_POLY_SET polyset_holes;
398 
399  potrace_dpoint_t( *c )[3];
400 
401  LOCALE_IO toggle; // Temporary switch the locale to standard C to r/w floats
402 
403  // The layer name has meaning only for .kicad_mod files.
404  // For these files the header creates 2 invisible texts: value and ref
405  // (needed but not usefull) on silk screen layer
407 
408  bool main_outline = true;
409 
410  /* draw each as a polygon with no hole.
411  * Bezier curves are approximated by a polyline
412  */
413  potrace_path_t* paths = m_Paths; // the list of paths
414 
415  if(!m_Paths)
416  {
417  m_errors += "No path in black and white image: no outline created\n";
418  }
419 
420  while( paths != NULL )
421  {
422  int cnt = paths->curve.n;
423  int* tag = paths->curve.tag;
424  c = paths->curve.c;
425  potrace_dpoint_t startpoint = c[cnt - 1][2];
426  for( int i = 0; i < cnt; i++ )
427  {
428  switch( tag[i] )
429  {
430  case POTRACE_CORNER:
431  cornersBuffer.push_back( c[i][1] );
432  cornersBuffer.push_back( c[i][2] );
433  startpoint = c[i][2];
434  break;
435 
436  case POTRACE_CURVETO:
437  BezierToPolyline( cornersBuffer, startpoint, c[i][0], c[i][1], c[i][2] );
438  startpoint = c[i][2];
439  break;
440  }
441  }
442 
443  // Store current path
444  if( main_outline )
445  {
446  main_outline = false;
447 
448  // build the current main polygon
449  polyset_areas.NewOutline();
450  for( unsigned int i = 0; i < cornersBuffer.size(); i++ )
451  {
452  polyset_areas.Append( int( cornersBuffer[i].x * m_ScaleX ),
453  int( cornersBuffer[i].y * m_ScaleY ) );
454  }
455  }
456  else
457  {
458  // Add current hole in polyset_holes
459  polyset_holes.NewOutline();
460  for( unsigned int i = 0; i < cornersBuffer.size(); i++ )
461  {
462  polyset_holes.Append( int( cornersBuffer[i].x * m_ScaleX ),
463  int( cornersBuffer[i].y * m_ScaleY ) );
464  }
465  }
466 
467  cornersBuffer.clear();
468 
469  /* at the end of a group of a positive path and its negative children, fill.
470  */
471  if( paths->next == NULL || paths->next->sign == '+' )
472  {
475  polyset_areas.BooleanSubtract( polyset_holes, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
476 
477  // Ensure there are no self intersecting polygons
478  polyset_areas.NormalizeAreaOutlines();
479 
480  // Convert polygon with holes to a unique polygon
482 
483  // Output current resulting polygon(s)
484  for( int ii = 0; ii < polyset_areas.OutlineCount(); ii++ )
485  {
486  SHAPE_LINE_CHAIN& poly = polyset_areas.Outline( ii );
487  outputOnePolygon( poly, getBoardLayerName( aModLayer ));
488  }
489 
490  polyset_areas.RemoveAllContours();
491  polyset_holes.RemoveAllContours();
492  main_outline = true;
493  }
494  paths = paths->next;
495  }
496 
497  outputDataEnd();
498 }
int OutlineCount() const
Return the number of vertices in a given outline/hole.
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:40
potrace_path_t * m_Paths
int NormalizeAreaOutlines()
Convert a self-intersecting polygon to one (or more) non self-intersecting polygon(s).
#define NULL
void outputDataHeader(const char *aBrdLayerName)
Function outputDataHeader write to file the header depending on file format.
Represent a set of closed polygons.
SHAPE_LINE_CHAIN & Outline(int aIndex)
const char * getBoardLayerName(BMP2CMP_MOD_LAYER aChoice)
void Simplify(POLYGON_MODE aFastMode)
int NewOutline()
Creates a new hole in a given outline.
void Fracture(POLYGON_MODE aFastMode)
Convert a single outline slitted ("fractured") polygon into a set ouf outlines with holes.
std::string m_errors
void outputDataEnd()
Function outputDataEnd write to file the last strings depending on file format.
static void BezierToPolyline(std::vector< potrace_dpoint_t > &aCornersBuffer, potrace_dpoint_t p1, potrace_dpoint_t p2, potrace_dpoint_t p3, potrace_dpoint_t p4)
void outputOnePolygon(SHAPE_LINE_CHAIN &aPolygon, const char *aBrdLayerName)
Function outputOnePolygon write one polygon to output file.
SHAPE_LINE_CHAIN.
void BooleanSubtract(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Perform boolean polyset intersection For aFastMode meaning, see function booleanOp.
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Add a new vertex to the contour indexed by aOutline and aHole (defaults to the outline of the last po...

References SHAPE_POLY_SET::Append(), BezierToPolyline(), SHAPE_POLY_SET::BooleanSubtract(), SHAPE_POLY_SET::Fracture(), getBoardLayerName(), m_errors, m_Paths, m_ScaleX, m_ScaleY, MOD_LYR_FSILKS, SHAPE_POLY_SET::NewOutline(), SHAPE_POLY_SET::NormalizeAreaOutlines(), NULL, SHAPE_POLY_SET::Outline(), SHAPE_POLY_SET::OutlineCount(), outputDataEnd(), outputDataHeader(), outputOnePolygon(), SHAPE_POLY_SET::PM_STRICTLY_SIMPLE, SHAPE_POLY_SET::RemoveAllContours(), and SHAPE_POLY_SET::Simplify().

Referenced by ConvertBitmap().

◆ getBoardLayerName()

const char * BITMAPCONV_INFO::getBoardLayerName ( BMP2CMP_MOD_LAYER  aChoice)
private
Returns
the board layer name depending on the board layer selected
Parameters
aChoice= the choice (MOD_LYR_FSILKS to MOD_LYR_FINAL)

Definition at line 162 of file bitmap2component.cpp.

163 {
164  const char * layerName = "F.SilkS";
165 
166  switch( aChoice )
167  {
168  case MOD_LYR_FSOLDERMASK:
169  layerName = "F.Mask";
170  break;
171 
172  case MOD_LYR_ECO1:
173  layerName = "Eco1.User";
174  break;
175 
176  case MOD_LYR_ECO2:
177  layerName = "Eco2.User";
178  break;
179 
180  case MOD_LYR_FSILKS:
181  default: // case MOD_LYR_FSILKS only unless there is a bug
182  break;
183  }
184 
185  return layerName;
186 }

References MOD_LYR_ECO1, MOD_LYR_ECO2, MOD_LYR_FSILKS, and MOD_LYR_FSOLDERMASK.

Referenced by createOutputData().

◆ GetErrorMessages()

std::string& BITMAPCONV_INFO::GetErrorMessages ( )
inline

Definition at line 77 of file bitmap2component.h.

77 {return m_errors; }
std::string m_errors

References m_errors.

Referenced by BM2CMP_FRAME::ExportToBuffer().

◆ outputDataEnd()

void BITMAPCONV_INFO::outputDataEnd ( )
private

Function outputDataEnd write to file the last strings depending on file format.

Definition at line 248 of file bitmap2component.cpp.

249 {
250  switch( m_Format )
251  {
252  case POSTSCRIPT_FMT:
253  m_Data += "grestore\n";
254  m_Data += "%%EOF\n";
255  break;
256 
257  case PCBNEW_KICAD_MOD:
258  m_Data += ")\n";
259  break;
260 
261  case KICAD_LOGO:
262  m_Data += ")\n";
263  break;
264 
265  case EESCHEMA_FMT:
266  m_Data += "ENDDRAW\n";
267  m_Data += "ENDDEF\n";
268  break;
269  }
270 }
enum OUTPUT_FMT_ID m_Format
std::string & m_Data

References EESCHEMA_FMT, KICAD_LOGO, m_Data, m_Format, PCBNEW_KICAD_MOD, and POSTSCRIPT_FMT.

Referenced by createOutputData().

◆ outputDataHeader()

void BITMAPCONV_INFO::outputDataHeader ( const char *  aBrdLayerName)
private

Function outputDataHeader write to file the header depending on file format.

Definition at line 189 of file bitmap2component.cpp.

190 {
191  int Ypos = (int) ( m_PixmapHeight / 2 * m_ScaleY );
192  int fieldSize; // fields text size = 60 mils
193  char strbuf[1024];
194 
195  switch( m_Format )
196  {
197  case POSTSCRIPT_FMT:
198  /* output vector data, e.g. as a rudimentary EPS file */
199  m_Data += "%%!PS-Adobe-3.0 EPSF-3.0\n";
200  sprintf( strbuf, "%%%%BoundingBox: 0 0 %d %d\n", m_PixmapWidth, m_PixmapHeight );
201  m_Data += strbuf;
202  m_Data += "gsave\n";
203  break;
204 
205  case PCBNEW_KICAD_MOD:
206  // fields text size = 1.5 mm
207  // fields text thickness = 1.5 / 5 = 0.3mm
208  sprintf( strbuf, "(module %s (layer F.Cu)\n (at 0 0)\n", m_CmpName.c_str() );
209  m_Data += strbuf;
210  sprintf( strbuf, "(attr board_only exclude_from_pos_files exclude_from_bom)\n");
211  m_Data += strbuf;
212  sprintf( strbuf, " (fp_text reference \"G***\" (at 0 0) (layer %s)\n"
213  " (effects (font (thickness 0.3)))\n )\n", aBrdLayerName );
214  m_Data += strbuf;
215  sprintf( strbuf, " (fp_text value \"%s\" (at 0.75 0) (layer %s) hide\n"
216  " (effects (font (thickness 0.3)))\n )\n", m_CmpName.c_str(), aBrdLayerName );
217  m_Data += strbuf;
218  break;
219 
220  case KICAD_LOGO:
221  m_Data += "(polygon (pos 0 0 rbcorner) (rotate 0) (linewidth 0.01)\n";
222  break;
223 
224  case EESCHEMA_FMT:
225  sprintf( strbuf, "EESchema-LIBRARY Version 2.3\n" );
226  m_Data += strbuf;
227  sprintf( strbuf, "#\n# %s\n", m_CmpName.c_str() );
228  m_Data += strbuf;
229  sprintf( strbuf, "# pixmap size w = %d, h = %d\n#\n",
231  m_Data += strbuf;
232 
233  // print reference and value
234  fieldSize = 50; // fields text size = 50 mils
235  Ypos += fieldSize / 2;
236  sprintf( strbuf, "DEF %s G 0 40 Y Y 1 F N\n", m_CmpName.c_str() );
237  m_Data += strbuf;
238  sprintf( strbuf, "F0 \"#G\" 0 %d %d H I C CNN\n", Ypos, fieldSize );
239  m_Data += strbuf;
240  sprintf( strbuf, "F1 \"%s\" 0 %d %d H I C CNN\n", m_CmpName.c_str(), -Ypos, fieldSize );
241  m_Data += strbuf;
242  m_Data += "DRAW\n";
243  break;
244  }
245 }
std::string m_CmpName
enum OUTPUT_FMT_ID m_Format
std::string & m_Data

References EESCHEMA_FMT, KICAD_LOGO, m_CmpName, m_Data, m_Format, m_PixmapHeight, m_PixmapWidth, m_ScaleY, PCBNEW_KICAD_MOD, and POSTSCRIPT_FMT.

Referenced by createOutputData().

◆ outputOnePolygon()

void BITMAPCONV_INFO::outputOnePolygon ( SHAPE_LINE_CHAIN aPolygon,
const char *  aBrdLayerName 
)
private

Function outputOnePolygon write one polygon to output file.

Polygon coordinates are expected scaled by the polygon extraction function

Definition at line 273 of file bitmap2component.cpp.

274 {
275  // write one polygon to output file.
276  // coordinates are expected in target unit.
277  int ii, jj;
278  VECTOR2I currpoint;
279  char strbuf[1024];
280 
281  int offsetX = (int)( m_PixmapWidth / 2 * m_ScaleX );
282  int offsetY = (int)( m_PixmapHeight / 2 * m_ScaleY );
283 
284  const VECTOR2I startpoint = aPolygon.CPoint( 0 );
285 
286  switch( m_Format )
287  {
288  case POSTSCRIPT_FMT:
289  offsetY = (int)( m_PixmapHeight * m_ScaleY );
290  sprintf( strbuf, "newpath\n%d %d moveto\n",
291  startpoint.x, offsetY - startpoint.y );
292  m_Data += strbuf;
293  jj = 0;
294  for( ii = 1; ii < aPolygon.PointCount(); ii++ )
295  {
296  currpoint = aPolygon.CPoint( ii );
297  sprintf( strbuf, " %d %d lineto",
298  currpoint.x, offsetY - currpoint.y );
299  m_Data += strbuf;
300 
301  if( jj++ > 6 )
302  {
303  jj = 0;
304  m_Data += "\n";
305  }
306  }
307 
308  m_Data += "\nclosepath fill\n";
309  break;
310 
311  case PCBNEW_KICAD_MOD:
312  {
313  double width = 0.0; // outline thickness in mm: no thickness
314  m_Data += " (fp_poly (pts";
315 
316  jj = 0;
317  for( ii = 0; ii < aPolygon.PointCount(); ii++ )
318  {
319  currpoint = aPolygon.CPoint( ii );
320  sprintf( strbuf, " (xy %f %f)",
321  ( currpoint.x - offsetX ) / PCB_IU_PER_MM,
322  ( currpoint.y - offsetY ) / PCB_IU_PER_MM );
323  m_Data += strbuf;
324 
325  if( jj++ > 6 )
326  {
327  jj = 0;
328  m_Data += "\n ";
329  }
330  }
331  // No need to close polygon
332  m_Data += " )";
333  sprintf( strbuf, "(layer %s) (width %f)\n )\n", aBrdLayerName, width );
334  m_Data += strbuf;
335  }
336  break;
337 
338  case KICAD_LOGO:
339  m_Data += " (pts";
340  // Internal units = micron, file unit = mm
341  jj = 0;
342  for( ii = 0; ii < aPolygon.PointCount(); ii++ )
343  {
344  currpoint = aPolygon.CPoint( ii );
345  sprintf( strbuf, " (xy %.3f %.3f)",
346  ( currpoint.x - offsetX ) / PL_IU_PER_MM,
347  ( currpoint.y - offsetY ) / PL_IU_PER_MM );
348  m_Data += strbuf;
349 
350  if( jj++ > 4 )
351  {
352  jj = 0;
353  m_Data += "\n ";
354  }
355  }
356  // Close polygon
357  sprintf( strbuf, " (xy %.3f %.3f) )\n",
358  ( startpoint.x - offsetX ) / PL_IU_PER_MM,
359  ( startpoint.y - offsetY ) / PL_IU_PER_MM );
360  m_Data += strbuf;
361  break;
362 
363  case EESCHEMA_FMT:
364  // The polygon outline thickness is fixed here to 1 mil, the minimal
365  // value in Eeschema (0 means use default thickness for graphics)
366  #define EE_LINE_THICKNESS 1
367  sprintf( strbuf, "P %d 0 0 %d",
368  (int) aPolygon.PointCount() + 1, EE_LINE_THICKNESS );
369  m_Data += strbuf;
370  for( ii = 0; ii < aPolygon.PointCount(); ii++ )
371  {
372  currpoint = aPolygon.CPoint( ii );
373  sprintf( strbuf, " %d %d",
374  currpoint.x - offsetX, currpoint.y - offsetY );
375  m_Data += strbuf;
376  }
377 
378  // Close polygon
379  sprintf( strbuf, " %d %d",
380  startpoint.x - offsetX, startpoint.y - offsetY );
381  m_Data += strbuf;
382 
383  m_Data += " F\n";
384  break;
385  }
386 }
Define a general 2D-vector/point.
Definition: vector2d.h:61
int PointCount() const
Function PointCount()
const VECTOR2I & CPoint(int aIndex) const
Function Point()
enum OUTPUT_FMT_ID m_Format
constexpr double PCB_IU_PER_MM
#define EE_LINE_THICKNESS
std::string & m_Data
constexpr double PL_IU_PER_MM

References SHAPE_LINE_CHAIN::CPoint(), EE_LINE_THICKNESS, EESCHEMA_FMT, KICAD_LOGO, m_Data, m_Format, m_PixmapHeight, m_PixmapWidth, m_ScaleX, m_ScaleY, PCB_IU_PER_MM, PCBNEW_KICAD_MOD, PL_IU_PER_MM, SHAPE_LINE_CHAIN::PointCount(), POSTSCRIPT_FMT, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by createOutputData().

Member Data Documentation

◆ m_CmpName

std::string BITMAPCONV_INFO::m_CmpName
private

Definition at line 63 of file bitmap2component.h.

Referenced by BITMAPCONV_INFO(), and outputDataHeader().

◆ m_Data

std::string& BITMAPCONV_INFO::m_Data
private

Definition at line 64 of file bitmap2component.h.

Referenced by outputDataEnd(), outputDataHeader(), and outputOnePolygon().

◆ m_errors

std::string BITMAPCONV_INFO::m_errors
private

Definition at line 65 of file bitmap2component.h.

Referenced by ConvertBitmap(), createOutputData(), and GetErrorMessages().

◆ m_Format

enum OUTPUT_FMT_ID BITMAPCONV_INFO::m_Format
private

◆ m_Paths

potrace_path_t* BITMAPCONV_INFO::m_Paths
private

Definition at line 62 of file bitmap2component.h.

Referenced by BITMAPCONV_INFO(), ConvertBitmap(), and createOutputData().

◆ m_PixmapHeight

int BITMAPCONV_INFO::m_PixmapHeight
private

◆ m_PixmapWidth

int BITMAPCONV_INFO::m_PixmapWidth
private

◆ m_ScaleX

double BITMAPCONV_INFO::m_ScaleX
private

◆ m_ScaleY

double BITMAPCONV_INFO::m_ScaleY
private

The documentation for this class was generated from the following files: