void rs_gen_func_normalize(int dest, float vmin, float vmax) {
// LAGGY !!!!!!!!!!!!!
float val_min = rs_gen_reg.tex[dest*rs_gen_reg.tex_length];
float val_max = rs_gen_reg.tex[dest*rs_gen_reg.tex_length];
float f;
int i, j;
for (i = 0; i < rs_gen_reg.tex_size; i++) {
for (j = 0; j < rs_gen_reg.tex_size; j++) {
f = rs_gen_reg.tex[dest*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] ;
val_max = rs_max(val_max, f);
val_min = rs_min(val_min, f);
};
};
float val_scale = (vmax - vmin) / (val_max - val_min) - vmin;
for (i = 0; i < rs_gen_reg.tex_size; i++) {
for (j = 0; j < rs_gen_reg.tex_size; j++) {
rs_gen_reg.tex[dest*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] =
vmin + val_scale * ( rs_gen_reg.tex[dest*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] - val_min);
};
};
};
int main(int argc, char **argv)
{
int fd = 0;
fprintf(stdout, "Let't demo cmake \n");
fprintf(stdout, "MAX(100, 200) = %d\n", rs_max(100, 200));
if ((fd = open("/tmp/cmake_lock", O_RDWR | O_CREAT, S_IRWXU | S_IRWXG)) < 0)
goto out;
rs_lock(fd);
/* do something */
fprintf(stdout, "record locking\n");
rs_unlock(fd);
out:
close(fd);
return 0;
}
double
Crop::sunlit_stomata_conductance () const
{ return LAI () / rs_max(); }
void TransformMesh::Initialize(int gridSize, int minGridSize, double gridSizeOverrideRatio,
RS_Bounds& srcExt, int srcW, int srcH,
RS_Bounds& destExt, int destW, int destH,
CSysTransformer* xformer,
bool invertYaxis)
{
_ASSERT(xformer != NULL);
_ASSERT(gridSize > 0 && minGridSize > 0 && srcW > 0 && srcH > 0 && destW > 0 && destH > 0);
_ASSERT(gridSizeOverrideRatio >= MIN_GRID_SIZE_OVERRIDE_RATIO && gridSizeOverrideRatio <= MAX_GRID_SIZE_OVERRIDE_RATIO);
// initialize members
m_minGridSize = minGridSize;
m_gridSizeOverrideRatio = gridSizeOverrideRatio;
int calculatedGridSize = gridSize;
// if the override is enabled (0 < ratio < 1), then adjust if necessary
if (gridSizeOverrideRatio < MAX_GRID_SIZE_OVERRIDE_RATIO
&& gridSizeOverrideRatio > MIN_GRID_SIZE_OVERRIDE_RATIO)
{
// the calculated grid size is the minimum of the passed in grid size and the overrided grid size
calculatedGridSize = rs_min(gridSize, (int)(rs_min(srcH, srcW) * m_gridSizeOverrideRatio));
}
// we check to make sure the minGridSize is less that gridSize
// -- in case we are given a minGridSize that is greater than the gridSize
// ensure grid size is not less than the minimum
if (minGridSize < gridSize)
{
calculatedGridSize = rs_max(minGridSize, calculatedGridSize);
}
// ensure grid size is not bigger than the source image's height and width
m_gridSizeHeight = rs_min(calculatedGridSize, srcH);
m_gridSizeWidth = rs_min(calculatedGridSize, srcW);
m_yAxisInverted = invertYaxis;
m_meshPoints.empty();
m_numVerticalPoints = 0;
m_numHorizontalPoints = 0;
double pixPerSrcUnitX = (double)srcW / srcExt.width();
double pixPerSrcUnitY = (double)srcH / srcExt.height();
double pixPerDestUnitX = (double)destW / destExt.width();
double pixPerDestUnitY = (double)destH / destExt.height();
// Create a grid in pixel space that covers the whole src extent
for (int gridX = 0; gridX < srcW + m_gridSizeWidth; gridX += m_gridSizeWidth)
{
++m_numHorizontalPoints;
// this sets the x-coordinate to the end pt if it gets close
if (gridX + MAX_GRID_EXPANSION_FACTOR * m_gridSizeWidth > srcW || gridX > srcW)
{
gridX = srcW;
}
for (int gridY = 0; gridY < srcH + m_gridSizeHeight; gridY += m_gridSizeHeight)
{
if (gridX == 0)
++m_numVerticalPoints;
// this sets the y-coordinate to the end pt if it gets close
if (gridY + MAX_GRID_EXPANSION_FACTOR * m_gridSizeHeight > srcH || gridY > srcH)
gridY = srcH;
// The point in pixel coordinates in the src image
RS_F_Point src_pt0(gridX, gridY);
// Convert from screen coordinates to src CS coordinates (note that the screen coords are inverted because the
// invert y axis based upon the setting
RS_F_Point srcCS_pt0(src_pt0.x / pixPerSrcUnitX + srcExt.minx,
(m_yAxisInverted ? (srcH - src_pt0.y) : src_pt0.y) / pixPerSrcUnitY + srcExt.miny);
// Convert from src cs to dest cs coordinates
RS_F_Point destCS_pt0(srcCS_pt0.x, srcCS_pt0.y);
xformer->TransformPoint(destCS_pt0.x, destCS_pt0.y);
// Convert from dest CS coordinates to dest pixel coordinates.
RS_F_Point dest_pt0((destCS_pt0.x - destExt.minx) * pixPerDestUnitX,
(destCS_pt0.y - destExt.miny) * pixPerDestUnitY);
// Store the point mapping in the transform mesh
MeshPoint mesh_pt;
mesh_pt.pt_src = src_pt0;
mesh_pt.pt_dest = dest_pt0;
m_meshPoints.push_back(mesh_pt);
}
}
}
void PolylineAdapter::Stylize(Renderer* renderer,
RS_FeatureReader* features,
bool initialPass,
FdoExpressionEngine* exec,
LineBuffer* geometry,
MdfModel::FeatureTypeStyle* style,
const MdfModel::MdfString* tooltip,
const MdfModel::MdfString* url,
RS_ElevationSettings* elevSettings,
CSysTransformer* /*layer2mapxformer*/)
{
m_exec = exec;
// no need to do anything if the style is not a line style, so quit
if (FeatureTypeStyleVisitor::DetermineFeatureTypeStyle(style) != FeatureTypeStyleVisitor::ftsLine)
return;
//-------------------------------------------------------
// determine the rule for the feature
//-------------------------------------------------------
MdfModel::RuleCollection* lrc = style->GetRules();
MdfModel::LineRule* rule = NULL;
for (int i=0; i<lrc->GetCount(); ++i)
{
rule = static_cast<MdfModel::LineRule*>(lrc->GetAt(i));
// apply any filter on the rule - if it fails move to the next rule
if (!ExecFdoFilter(&rule->GetFilter()))
{
// don't stylize with failed rule
rule = NULL;
continue;
}
break;
}
if (!rule)
return;
MdfModel::LineSymbolizationCollection* lsymc = rule->GetSymbolizations();
if (lsymc == NULL)
return;
int nSyms = lsymc->GetCount();
//-------------------------------------------------------
// evaluate all the styles once
//-------------------------------------------------------
// temporary array used to store pointers to each evaluated style
RS_LineStroke** ppStrokes = (RS_LineStroke**)alloca(nSyms * sizeof(RS_LineStroke*));
if (!ppStrokes)
return;
size_t tempIndex = 0;
for (int i=0; i<nSyms; ++i)
{
MdfModel::LineSymbolization2D* lsym = lsymc->GetAt(i);
// don't render if there's no symbolization
if (lsym == NULL)
{
ppStrokes[i] = NULL;
continue;
}
// quick check if style is already cached
RS_LineStroke* cachedStyle = m_hLineSymCache[lsym];
if (cachedStyle)
{
ppStrokes[i] = cachedStyle;
}
else
{
// if not, then we need to either cache or evaluate it
// make sure the vector has a style in the slot we need
if (tempIndex >= m_lineSyms.size())
{
_ASSERT(tempIndex == m_lineSyms.size());
// allocate a new style and add it to the vector
m_lineSyms.push_back(new RS_LineStroke());
}
// use the existing style in the vector
ppStrokes[i] = m_lineSyms[tempIndex];
ObtainStyle(lsym, *ppStrokes[i]);
++tempIndex;
}
}
//-------------------------------------------------------
// compute the clip offset from the styles
//-------------------------------------------------------
double clipOffsetWU = 0.0; // in mapping units
bool bClip = renderer->RequiresClipping();
bool bLabelClip = renderer->RequiresLabelClipping();
if (bClip || bLabelClip)
{
double mapScale = renderer->GetMapScale();
double clipOffsetMeters = 0.0; // in device units
for (int i=0; i<nSyms; ++i)
{
if (ppStrokes[i])
{
double styleClipOffset = GetClipOffset(*ppStrokes[i], mapScale);
clipOffsetMeters = rs_max(styleClipOffset, clipOffsetMeters);
}
}
// add one pixel's worth to handle any roundoff
clipOffsetMeters += METERS_PER_INCH / renderer->GetDpi();
// limit the offset to something reasonable
if (clipOffsetMeters > MAX_CLIPOFFSET_IN_METERS)
clipOffsetMeters = MAX_CLIPOFFSET_IN_METERS;
// convert to mapping units
clipOffsetWU = clipOffsetMeters * mapScale / renderer->GetMetersPerUnit();
}
//-------------------------------------------------------
// prepare the geometry on which to apply the style
//-------------------------------------------------------
LineBuffer* lb = geometry;
std::auto_ptr<LineBuffer> spClipLB;
if (bClip)
{
// the clip region is the map request extents expanded by the offset
RS_Bounds clip = renderer->GetBounds();
clip.minx -= clipOffsetWU;
clip.miny -= clipOffsetWU;
clip.maxx += clipOffsetWU;
clip.maxy += clipOffsetWU;
// clip geometry to given extents
LineBuffer* lbc = lb->Clip(clip, LineBuffer::ctAGF, m_lbPool);
if (lbc != lb)
{
// if the clipped buffer is NULL (completely clipped) just move on to
// the next feature
if (!lbc)
return;
// otherwise continue processing with the clipped buffer
lb = lbc;
if (lb != geometry)
spClipLB.reset(lb);
}
}
//-------------------------------------------------------
// do the StartFeature notification
//-------------------------------------------------------
RS_String tip; //TODO: this should be quick since we are not assigning
RS_String eurl;
const RS_String &theme = rule->GetLegendLabel();
if (tooltip && !tooltip->empty())
EvalString(*tooltip, tip);
if (url && !url->empty())
EvalString(*url, eurl);
// elevation settings
RS_ElevationType elevType = RS_ElevationType_RelativeToGround;
double zOffset = 0.0;
double zExtrusion = 0.0;
GetElevationParams(elevSettings, zOffset, zExtrusion, elevType);
renderer->StartFeature(features, initialPass,
tip.empty()? NULL : &tip,
eurl.empty()? NULL : &eurl,
theme.empty()? NULL : &theme,
zOffset, zExtrusion, elevType);
//-------------------------------------------------------
// apply the style to the geometry using the renderer
//-------------------------------------------------------
for (int i=0; i<nSyms; ++i)
{
if (ppStrokes[i])
renderer->ProcessPolyline(lb, *ppStrokes[i]);
}
//-------------------------------------------------------
// do labeling if needed
//-------------------------------------------------------
MdfModel::Label* label = rule->GetLabel();
if (label && label->GetSymbol())
{
// Make sure the geometry is clipped if label clipping is specified.
// If bClip is true then the geometry is already clipped.
if (!bClip && bLabelClip)
{
// the clip region is the map request extents expanded by the offset
RS_Bounds clip = renderer->GetBounds();
clip.minx -= clipOffsetWU;
clip.miny -= clipOffsetWU;
clip.maxx += clipOffsetWU;
clip.maxy += clipOffsetWU;
LineBuffer* lbc = lb->Clip(clip, LineBuffer::ctAGF, m_lbPool);
if (lbc != lb)
{
// if the clipped buffer is NULL (completely clipped) just move on to
// the next feature
if (!lbc)
return;
// otherwise continue processing with the clipped buffer
lb = lbc;
if (lb != geometry)
spClipLB.reset(lb);
}
}
double cx = std::numeric_limits<double>::quiet_NaN();
double cy = std::numeric_limits<double>::quiet_NaN();
double slope_rad = 0.0;
// multi should work for simple polylines too
lb->Centroid(LineBuffer::ctLine, &cx, &cy, &slope_rad);
if (!_isnan(cx) && !_isnan(cy))
AddLabel(cx, cy, slope_rad, true, label, RS_OverpostType_AllFit, true, renderer, label->GetSymbol()->IsAdvancedPlacement()? lb : NULL);
}
// free clipped line buffer if the geometry was clipped
if (spClipLB.get())
LineBufferPool::FreeLineBuffer(m_lbPool, spClipLB.release());
}
void rs_sgen_func_normalize(int dest, float amp) {
// DEBUG10("Normalize...");
float val_max = 0.0; // fabs(rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest ]);
float f;
int i;
// Step 1: Normalize Mid-line
const int mar_samples_count = 512;
float *mar = malloc( 4 * (2 + rs_sgen_reg.wave_length / mar_samples_count) );
memset(mar, 0, 4 * (2 + rs_sgen_reg.wave_length / mar_samples_count) );
// DEBUG10("label 1");
int length_512 = mar_samples_count*(rs_sgen_reg.wave_length/mar_samples_count); // 1024 for 1027
int last_length = rs_sgen_reg.wave_length - length_512;
if (!last_length) {
last_length = length_512;
};
float koef[2] = { 1.0/mar_samples_count, 1.0/(last_length) };
// DEBUG10f("\nkoef 0: %.6f\nkoef 1: %.6f (last_length = %d)\n", koef[0], koef[1], last_length);
for (i = 0; i < rs_sgen_reg.wave_length; i++) {
mar[1+i/mar_samples_count] += koef[ i / (length_512) ] * rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i];
};
// DEBUG10("label 2");
for (i = 0; i < rs_sgen_reg.wave_length; i++) {
rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i] -= //mar[i/mar_samples_count];
rs_linear_interpolate( mar[i/mar_samples_count], mar[1+i/mar_samples_count], rs_fract(1.0*i/mar_samples_count) );
};
//
// DEBUG10("label 3");
free(mar);
// DEBUG10("label 4");
// Step 2: Normalize Amplitude
for (i = 0; i < rs_sgen_reg.wave_length; i++) {
f = rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i];
val_max = rs_max(val_max, fabs(f) );
};
float val_scale = amp / val_max;
// DEBUG10f("SGEN Normalize: val_max %.3f, val_scale = %.3f \n", val_max, val_scale);
for (i = 0; i < rs_sgen_reg.wave_length; i++) {
rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i] = val_scale * rs_sgen_reg.wave[ rs_sgen_reg.wave_length * dest + i];
};
};
void rs_gen_func_normalmap(int dest_r, int dest_g, int dest_b, int src, float k) {
int i, j;
float max_val = -111111.0;
float min_val = 100000.0;
for (i = 0; i < rs_gen_reg.tex_size; i++) {
for (j = 0; j < rs_gen_reg.tex_size; j++) {
unsigned short um = rs_gen_reg.tex_size + j-2;
unsigned short vm = rs_gen_reg.tex_size + i-2;
unsigned short u = j;
unsigned short v = i;
unsigned short up = j+2;
unsigned short vp = i+2;
um %= rs_gen_reg.tex_size;
vm %= rs_gen_reg.tex_size;
up %= rs_gen_reg.tex_size;
vp %= rs_gen_reg.tex_size;
// float val1 = rs_gen_reg.tex[src*rs_gen_reg.tex_length + v*rs_gen_reg.tex_size + u];
float val_xp = 2.0 * rs_gen_reg.tex[src*rs_gen_reg.tex_length + v*rs_gen_reg.tex_size + up]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vm*rs_gen_reg.tex_size + up]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vp*rs_gen_reg.tex_size + up];
float val_xm = 2.0 * rs_gen_reg.tex[src*rs_gen_reg.tex_length + v*rs_gen_reg.tex_size + um]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vm*rs_gen_reg.tex_size + um]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vp*rs_gen_reg.tex_size + um];
float val_yp = 2.0 * rs_gen_reg.tex[src*rs_gen_reg.tex_length + vp*rs_gen_reg.tex_size + u]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vp*rs_gen_reg.tex_size + um]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vp*rs_gen_reg.tex_size + up];
float val_ym = 2.0 * rs_gen_reg.tex[src*rs_gen_reg.tex_length + vm*rs_gen_reg.tex_size + u]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vm*rs_gen_reg.tex_size + um]
+ rs_gen_reg.tex[src*rs_gen_reg.tex_length + vm*rs_gen_reg.tex_size + up];
// float val_dx = rs_gen_reg.tex[src*rs_gen_reg.tex_length + v*rs_gen_reg.tex_size + u2] - val1;
// float val_dy = rs_gen_reg.tex[src*rs_gen_reg.tex_length + v2*rs_gen_reg.tex_size + u] - val1;
float val_dx = val_xp - val_xm;
float val_dy = val_yp - val_ym;
// val_dx = val_dx;
// val_dy = -val_dy;
// val_dx = atan(val_dx * rs_gen_reg.tex_size ) / (M_PI/2);
// val_dy = atan(val_dy * rs_gen_reg.tex_size ) / (M_PI/2);
float bump_scale = 128.0 / rs_gen_reg.tex_size / k;
rs_vec3_t bump = rs_vec3_cross( rs_vec3_normalize(rs_vec3(bump_scale, 0.0, val_dy)),
rs_vec3_normalize(rs_vec3(0.0, bump_scale, -val_dx)));
float val_dz = sqrtf( 1.0 - (RS_SQR(k*val_dx) + RS_SQR(k*val_dy)) );
// val_dz = val_dz;
// val_dz = 1.0 / 2.0;
val_dx = 0.5 + 0.5*val_dx;
val_dy = 0.5 + 0.5*val_dy;
val_dz = 0.5 + 0.5*val_dz;
max_val = rs_max(max_val, fabs(val_dx) );
// max_val = rs_max(max_val, fabs(val_dy) );
min_val = rs_min(min_val, val_dx);
// min_val = rs_min(min_val, val_dy);
// rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = val_dy;
// rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = val_dx;
// rs_gen_reg.tex[dest_b*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = val_dz;
rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = 0.5 + 0.5*bump.x;
rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = 0.5 + 0.5*bump.y;
rs_gen_reg.tex[dest_b*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = 0.5 + 0.5*bump.z;
};
};
////// if (max_val < 0.001) {
////// DEBUG10f("WARNING, max_val of normalmap is too low (%.9f) \n", max_val);
////// max_val = 0.001;
////// };
//////
////// max_val *= 1.0;
//////
////// for (i = 0; i < rs_gen_reg.tex_size; i++) {
////// for (j = 0; j < rs_gen_reg.tex_size; j++) {
//////
////// rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] /= max_val;
////// rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] /= max_val;
//////
////// rs_gen_reg.tex[dest_b*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] =
////// sqrtf( 1.0 - (RS_SQR(rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j])
////// + RS_SQR(rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j])) );
//////
//////
////// rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] =
////// 0.5 + 0.5*rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j];
////// rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] =
////// 0.5 + 0.5*rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j];
//////
//////
//////// float val_dx = rs_gen_reg.tex[dest_r*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j];
//////// float val_dy = rs_gen_reg.tex[dest_g*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j];
////////
//////// float val_dz = sqrtf( 1.0 - (RS_SQR(k*val_dx) + RS_SQR(k*val_dy)) );
//////
//////// val_dx = 0.5 + 0.5*k*val_dx;
//////// val_dy = 0.5 + 0.5*k*val_dy;
//////// val_dz = 0.5 + 0.5*val_dz;
//////
//////
////// //rs_gen_reg.tex[dest_b*rs_gen_reg.tex_length + i*rs_gen_reg.tex_size + j] = val_dz;
//////
////// };
////// };
// DEBUG10f("\n\nmax val %.3f \nmin %.3f \n", max_val, min_val);
};
