//---------------------------------------------------------
inline void CGrid_3D_Image::_Draw_Line(int xa, int xb, int y, double za, double zb, double ra, double rb, double ga, double gb, double ba, double bb)
{
double d, dz, dr, dg, db;
if( (d = xb - xa) > 0.0 )
{
dz = (zb - za) / d;
dr = (rb - ra) / d;
dg = (gb - ga) / d;
db = (bb - ba) / d;
if( xa < 0 )
{
za -= dz * xa;
ra -= dr * xa;
ga -= dg * xa;
ba -= db * xa;
xa = 0;
}
if( xb >= m_pRGB->Get_NX() )
{
xb = m_pRGB->Get_NX() - 1;
}
for(int x=xa; x<=xb; x++, za+=dz, ra+=dr, ga+=dg, ba+=db)
{
_Draw_Pixel(x, y, za, (int)ra, (int)ga, (int)ba);
}
}
else if( xa >= 0 && xa < m_pRGB->Get_NX() )
{
_Draw_Pixel(xa, y, za, (int)ra, (int)ga, (int)ba);
}
}
//---------------------------------------------------------
void CSG_3DView_Canvas::Draw_Line(double ax, double ay, double az, double bx, double by, double bz, int aColor, int bColor)
{
if( (ax < 0 && bx < 0) || (ax >= m_Image_NX && bx >= m_Image_NX)
|| (ay < 0 && by < 0) || (ay >= m_Image_NY && by >= m_Image_NY) )
{
return;
}
double dx = bx - ax;
double dy = by - ay;
double dz = bz - az;
if( bz < 0.0 || az < 0.0 )
{
return;
}
double n;
if( fabs(dx) > fabs(dy) && fabs(dx) > 0.0 )
{
n = fabs(dx);
dx = dx < 0 ? -1 : 1;
dy /= n;
dz /= n;
}
else if( fabs(dy) > 0.0 )
{
n = fabs(dy);
dx /= n;
dy = dy < 0 ? -1 : 1;
dz /= n;
}
else
{
_Draw_Pixel((int)ax, (int)ay, az, aColor);
_Draw_Pixel((int)bx, (int)by, bz, bColor);
return;
}
//-----------------------------------------------------
CSG_Colors Colors(2); Colors[0] = aColor; Colors[1] = bColor;
//-----------------------------------------------------
for(double i=0.0; i<=n; i++, ax+=dx, ay+=dy, az+=dz)
{
_Draw_Pixel((int)ax, (int)ay, az, Colors.Get_Interpolated(i / n));
}
}
//---------------------------------------------------------
inline void CSG_3DView_Canvas::_Draw_Triangle_Line(int y, double xa, double xb, double za, double zb, double ca, double cb, double da, double db, double dim)
{
if( xb < xa )
{
double d;
d = xa; xa = xb; xb = d;
d = za; za = zb; zb = d;
d = ca; ca = cb; cb = d;
d = da; da = db; db = d;
}
if( xb > xa )
{
double dz = (zb - za) / (xb - xa);
double dc = (cb - ca) / (xb - xa);
double dd = (db - da) / (xb - xa);
int ax = (int)xa; if( ax < 0 ) ax = 0; if( ax < xa ) ax++;
int bx = (int)xb; if( bx >= m_Image_NX ) bx = m_Image_NX - 1;
for(int x=ax; x<=bx; x++)
{
double z = za + dz * (x - xa);
double c = ca + dc * (x - xa);
double d = da + dd * (x - xa);
if( m_pDrape )
{
if( m_pDrape->Get_Value(c, d, c, m_Drape_Mode, false, true) )
{
_Draw_Pixel(x, y, z, _Dim_Color((int)(0.5 + c), dim));
}
}
else
{
_Draw_Pixel(x, y, z, _Dim_Color(Get_Color(c), dim));
}
}
}
}
//---------------------------------------------------------
void CSG_3DView_Canvas::Draw_Point(int x, int y, double z, int color, int size)
{
if( z > 0.0 )
{
_Draw_Pixel(x, y, z, color);
if( size > 0 && size < 50 )
{
for(int iy=1; iy<=size; iy++)
{
for(int ix=0; ix<=size; ix++)
{
if( ix*ix + iy*iy <= size*size )
{
_Draw_Pixel(x + ix, y + iy, z, color);
_Draw_Pixel(x + iy, y - ix, z, color);
_Draw_Pixel(x - ix, y - iy, z, color);
_Draw_Pixel(x - iy, y + ix, z, color);
}
}
}
}
}
}
//---------------------------------------------------------
bool CPoints_View_Extent::_Draw_Image(void)
{
if( m_pPoints->Get_Count() <= 0 || m_pPoints->Get_Extent().Get_XRange() <= 0.0 || m_pPoints->Get_Extent().Get_YRange() <= 0.0
|| m_cField < 0 || m_cField >= m_pPoints->Get_Field_Count() )
{
return( false );
}
//-------------------------------------------------
wxSize Size;
double dx, dy;
Size = GetClientSize();
if (Size.x <= 0 || Size.y <= 0) // temporary hack for wxGTK to suppress 'assert "isOK()" failed in Get_Height(): invalid image'
return( false ); // when dlg.ShowModal() is called; during construction everything is fine, but the first call of
// the On_Size() event returns a client size of 0
m_Image .Create(Size.x, Size.y);
m_Image_Value .Create(Size.x, Size.y);
m_Image_Count .Create(Size.x, Size.y);
//-------------------------------------------------
m_Extent = m_pPoints->Get_Extent();
if( (dx = Size.y / (double)Size.x) < (m_Extent.Get_YRange() / m_Extent.Get_XRange()) )
{
dx = 0.5 * (m_Extent.Get_XRange() - m_Extent.Get_YRange() / dx);
m_Extent.m_rect.xMin += dx;
m_Extent.m_rect.xMax -= dx;
}
else
{
dy = 0.5 * (m_Extent.Get_YRange() - m_Extent.Get_XRange() * dx);
m_Extent.m_rect.yMin += dy;
m_Extent.m_rect.yMax -= dy;
}
dx = Size.x / m_Extent.Get_XRange();
dy = Size.y / m_Extent.Get_YRange();
//-------------------------------------------------
bool bColorAsRGB = m_Settings("C_AS_RGB")->asBool();
for(int i=0; i<m_pPoints->Get_Count(); i++)
{
TSG_Point_Z p = m_pPoints->Get_Point(i); p.z = m_pPoints->Get_Value(i, m_cField);
int ix = (p.x - m_Extent.Get_XMin()) * dx;
int iy = (p.y - m_Extent.Get_YMin()) * dy;
if( ix >= 0 && ix <= m_Image.GetWidth() && iy >= 0 && iy < m_Image.GetHeight() )
{
if( !bColorAsRGB )
{
m_Image_Value[iy][ix] += p.z;
}
else
{
m_Image_Value[iy][ix] = p.z;
}
m_Image_Count[iy][ix]++;
}
}
//-------------------------------------------------
double zMin = m_pPoints->Get_Mean(m_cField) - 1.5 * m_pPoints->Get_StdDev(m_cField);
double zRange = m_pPoints->Get_Mean(m_cField) + 1.5 * m_pPoints->Get_StdDev(m_cField) - zMin;
CSG_Colors *pColors = m_Settings("COLORS")->asColors();
for(int iy=0; iy<m_Image.GetHeight(); iy++)
{
for(int ix=0; ix<m_Image.GetWidth(); ix++)
{
if( m_Image_Count[iy][ix] > 0 )
{
if( !bColorAsRGB )
{
int ic = (int)(pColors->Get_Count() * (m_Image_Value[iy][ix] / m_Image_Count[iy][ix] - zMin) / zRange);
int c = pColors->Get_Color(ic < 0 ? 0 : ic >= pColors->Get_Count() ? pColors->Get_Count() - 1 : ic);
_Draw_Pixel(ix, iy, c);
}
else
{
_Draw_Pixel(ix, iy, m_Image_Value[iy][ix]);
}
}
else
{
_Draw_Pixel(ix, iy, 0);
}
}
}
return( true );
}
//---------------------------------------------------------
void CGrid_3D_Image::_Draw_Triangle(T3DPoint p[3])
{
int i, j, k, y, y_j;
double x[2], dx[2], dy, z[2], dz[2], r[2], dr[2], g[2], dg[2], b[2], db[2];
T3DPoint pp;
//-----------------------------------------------------
if( !p[0].bOk || !p[1].bOk || !p[2].bOk )
{
return;
}
//-----------------------------------------------------
SORT_POINTS_Y(1, 0);
SORT_POINTS_Y(2, 0);
SORT_POINTS_Y(2, 1);
//-----------------------------------------------------
if( p[2].y == p[0].y )
{
if( p[0].y >= 0 && p[0].y < m_pRGB->Get_NY() )
{
SORT_POINTS_X(1, 0);
SORT_POINTS_X(2, 0);
SORT_POINTS_X(2, 1);
//---------------------------------------------
if( p[2].x == p[0].x )
{
if( p[0].x >= 0 && p[0].x < m_pRGB->Get_NX() )
{
i = p[0].z > p[1].z ? (p[0].z > p[2].z ? 0 : 2) : (p[1].z > p[2].z ? 1 : 2);
_Draw_Pixel(p[0].x, p[0].y, p[i].z, p[i].r, p[i].g, p[i].b);
}
}
//---------------------------------------------
else
{
_Draw_Line(p[0].x, p[1].x, p[0].y, p[0].z, p[1].z, p[0].r, p[1].r, p[0].g, p[1].g, p[0].b, p[1].b);
_Draw_Line(p[1].x, p[2].x, p[0].y, p[1].z, p[2].z, p[1].r, p[2].r, p[1].g, p[2].g, p[1].b, p[2].b);
}
}
}
//-----------------------------------------------------
else if( !((p[0].y < 0 && p[2].y < 0) || (p[0].y >= m_pRGB->Get_NY() && p[2].y >= m_pRGB->Get_NY())) )
{
dy = p[2].y - p[0].y;
dx[0] = (p[2].x - p[0].x) / dy;
dz[0] = (p[2].z - p[0].z) / dy;
dr[0] = (p[2].r - p[0].r) / dy;
dg[0] = (p[2].g - p[0].g) / dy;
db[0] = (p[2].b - p[0].b) / dy;
x [0] = p[0].x;
z [0] = p[0].z;
r [0] = p[0].r;
g [0] = p[0].g;
b [0] = p[0].b;
for(i=0, j=1; i<2; i++, j++)
{
if( (dy = p[j].y - p[i].y) > 0.0 )
{
dx[1] = (p[j].x - p[i].x) / dy;
dz[1] = (p[j].z - p[i].z) / dy;
dr[1] = (p[j].r - p[i].r) / dy;
dg[1] = (p[j].g - p[i].g) / dy;
db[1] = (p[j].b - p[i].b) / dy;
x [1] = p[i].x;
z [1] = p[i].z;
r [1] = p[i].r;
g [1] = p[i].g;
b [1] = p[i].b;
if( (y = p[i].y) < 0 )
{
x[1] -= y * dx[1];
z[1] -= y * dz[1];
r[1] -= y * dr[1];
g[1] -= y * dg[1];
b[1] -= y * db[1];
y = 0;
x[0] = p[0].x - p[0].y * dx[0];
z[0] = p[0].z - p[0].y * dz[0];
r[0] = p[0].r - p[0].y * dr[0];
g[0] = p[0].g - p[0].y * dg[0];
b[0] = p[0].b - p[0].y * db[0];
}
if( (y_j = p[j].y) > m_pRGB->Get_NY() )
{
y_j = m_pRGB->Get_NY();
}
for( ; y<y_j; y++)
{
if( x[1] < x[0] )
{
_Draw_Line((int)x[1], (int)x[0], y, z[1], z[0], r[1], r[0], g[1], g[0], b[1], b[0]);
}
else
{
_Draw_Line((int)x[0], (int)x[1], y, z[0], z[1], r[0], r[1], g[0], g[1], b[0], b[1]);
}
for(k=0; k<=1; k++)
{
x[k] += dx[k];
z[k] += dz[k];
r[k] += dr[k];
g[k] += dg[k];
b[k] += db[k];
}
}
}
}
}
}
