void draw_filledCircleSlice(
unsigned int x, unsigned int y,
double rad,
uint8_t r,
uint8_t g,
uint8_t b,
uint16_t slice_begin,
uint16_t slice_end)
{
uint8_t i,j;
if(slice_begin > slice_end)
{
swap_(slice_begin,slice_end);
}
for(i=0;i<(rad*2);i++)
{
for(j=0;j<(rad*2);j++)
{
double dist = pythagoras( j,i );
if(dist <= rad-1)
{
setLedXY(y-j,x+i,r,g,b);
}else if(dist < rad)
{
// dla_plot(y-j,x+i,r,g,b,1-(dist-rad+1));
}
}
}
}
main()
{
printf("\n%s\n%s\n", "Geef een waarde voor a en b, gescheiden door een spatie",
"Het resultaat is dan de lengte van de lange zijde");
int a , b;
scanf("%d%d", &a, &b);
printf("de lange zijde heeft lengte: %d \n", pythagoras(a, b));
}
void drvJAVA2::show_text(const TextInfo & textinfo)
{
if (numberOfElements > limitNumberOfElements)
continue_page();
unsigned int javaFontNumber = getFontNumber(textinfo.currentFontName.value());
outf << " currentPage.add(new PSTextObject(new Color(";
outf << currentR() << "f, " << currentG() << "f, " << currentB() << "f)," << endl;
outf << " \"";
for (const char *p = textinfo.thetext.value(); (*p) != 0; p++) {
if ((*p) == '"') {
outf << '\\' << *p;
} else if ((*p) == '\\') {
outf << '\\' << *p;
} else if ((*p) == (char) 13) { // ^M
outf << ' ';
} else {
outf << *p;
}
}
outf << "\"," << endl;
outf << " " << (textinfo.x +
x_offset) << "f, " << (currentDeviceHeight - textinfo.y + y_offset) << "f";
#ifdef PASSFONTNAME
const char *javaFname = JavaFonts[javaFontNumber].javaname;
const char *javaFstyle = JavaFonts[javaFontNumber].javastyle;
outf << ", \"" << javaFname << "\", " << javaFstyle;
#else
outf << ", " << javaFontNumber;
#endif
const float *CTM = getCurrentFontMatrix();
if ((fabs(pythagoras(CTM[0], CTM[1] ) - textinfo.currentFontSize) < 1e-5)
&& (fabs(pythagoras(CTM[2] ,CTM[3] ) - textinfo.currentFontSize) < 1e-5)
&& (CTM[0] * CTM[3] - CTM[1] * CTM[2] >= 0)) {
outf << ", " << textinfo.currentFontSize << "f";
if (textinfo.currentFontAngle) {
outf << ", " << textinfo.currentFontAngle << "f";
}
} else {
outf << ", new AffineTransform(" << CTM[0] << "f, " << (-CTM[1]) << "f, ";
outf << (-CTM[2]) << "f, " << CTM[3] << "f, 0f, 0f)";
}
outf << "));" << endl;
numberOfElements++;
}
void drvGCODE::show_path()
{
Point currentPoint(0.0f, 0.0f);
const Point firstPoint = pathElement(0).getPoint(0);
for (unsigned int n = 0; n < numberOfElementsInPath(); n++) {
const basedrawingelement & elem = pathElement(n);
switch (elem.getType()) {
case moveto:{
const Point & p = elem.getPoint(0);
outf << "\nG00 Z#1000\n";
outf << "G00 X[#1003*" << p.x_ << "] Y[#1004*" << p.y_ << "]\n";
outf << "G01 Z#1002\n";
currentPoint = p;
}
break;
case lineto:{
const Point & p = elem.getPoint(0);
outf << "G01 X[#1003*" << p.x_ << "] Y[#1004*" << p.y_ << "]\n";
currentPoint = p;
}
break;
case closepath:
outf << "G01 X[#1003*" << firstPoint.x_ << "] Y[#1004*" << firstPoint.y_ << "]\n";
break;
case curveto:{
const Point & cp1 = elem.getPoint(0);
const Point & cp2 = elem.getPoint(1);
const Point & ep = elem.getPoint(2);
// curve is approximated with a variable number or linear segments.
// fitpoints should be somewhere between 5 and 50 for reasonable page size plots
// we compute distance between current point and endpoint and use that to help
// pick the number of segments to use.
const float dist = (float) pythagoras((float)(ep.x_ - currentPoint.x_),(float)(ep.y_ - currentPoint.y_));
unsigned int fitpoints = (unsigned int)(dist / 10.0);
if ( fitpoints < 5 ) fitpoints = 5;
if ( fitpoints > 50 ) fitpoints = 50;
for (unsigned int s = 1; s < fitpoints; s++) {
const float t = 1.0f * s / (fitpoints - 1);
const Point pt = PointOnBezier(t, currentPoint, cp1, cp2, ep);
outf << " G01 X[#1003*" << pt.x_ << "] Y[#1004*" << pt.y_ << "]\n";
}
currentPoint = ep;
}
break;
default:
errf << "\t\tFatal: unexpected case in drvgcode " << endl;
abort();
break;
}
}
}
void draw_filledCircle(
unsigned int x, unsigned int y,
double rad,
uint8_t r,
uint8_t g,
uint8_t b )
{
uint8_t i,j;
for(i=0;i<rad;i++)
{
for(j=0;j<(i+1);j++)
{
double dist = pythagoras( j,i );
if(dist <= rad-1)
{
setLedXY(y-j,x+i,r,g,b);
setLedXY(y+j,x+i,r,g,b);
setLedXY(y+j,x-i,r,g,b);
setLedXY(y-j,x-i,r,g,b);
setLedXY(y-i,x-j,r,g,b);
setLedXY(y-i,x+j,r,g,b);
setLedXY(y+i,x+j,r,g,b);
setLedXY(y+i,x-j,r,g,b);
}else if(dist < rad)
{
dla_plot(y-j,x+i,r,g,b,1-(dist-rad+1));
dla_plot(y+j,x+i,r,g,b,1-(dist-rad+1));
dla_plot(y+j,x-i,r,g,b,1-(dist-rad+1));
dla_plot(y-j,x-i,r,g,b,1-(dist-rad+1));
dla_plot(y-i,x+j,r,g,b,1-(dist-rad+1));
dla_plot(y+i,x+j,r,g,b,1-(dist-rad+1));
dla_plot(y+i,x-j,r,g,b,1-(dist-rad+1));
dla_plot(y-i,x-j,r,g,b,1-(dist-rad+1));
}
}
}
}
int main()
{
FILE* input = fopen("circle.in","r");
int i;
double x[3],y[3],s,mx,my,r;
while (1)
{
for (i=0; i<3; i++)
fscanf(input,"%lf %lf",&x[i],&y[i]);
if (feof(input)) break;
s = cramer2(y[1]-y[0],y[1]-y[2],x[0]-x[1],x[2]-x[1],
0.5*(x[2]-x[0]),0.5*(y[2]-y[0]));
mx = 0.5*(x[1]+x[2])+s*(y[2]-y[1]);
my = 0.5*(y[1]+y[2])+s*(x[1]-x[2]);
r = pythagoras(mx-x[0],my-y[0]);
printf("%.2f\n",2*PI*r);
}
fclose(input);
return 0;
}
void discretise_structure( struct Structure This_Structure , float grid_span , int grid_size , float *grid ) {
/************/
/* Counters */
int residue , atom ;
/* Co-ordinates */
int x , y , z ;
int steps , x_step , y_step , z_step ;
float x_centre , y_centre , z_centre ;
/* Variables */
float distance , one_span ;
/************/
one_span = grid_span / (float)grid_size ;
distance = 1.8 ;
/************/
for( x = 0 ; x < grid_size ; x ++ ) {
for( y = 0 ; y < grid_size ; y ++ ) {
for( z = 0 ; z < grid_size ; z ++ ) {
grid[gaddress(x,y,z,grid_size)] = (float)0 ;
}
}
}
/************/
steps = (int)( ( distance / one_span ) + 1.5 ) ;
for( residue = 1 ; residue <= This_Structure.length ; residue ++ ) {
for( atom = 1 ; atom <= This_Structure.Residue[residue].size ; atom ++ ) {
x = gord( This_Structure.Residue[residue].Atom[atom].coord[1] , grid_span , grid_size ) ;
y = gord( This_Structure.Residue[residue].Atom[atom].coord[2] , grid_span , grid_size ) ;
z = gord( This_Structure.Residue[residue].Atom[atom].coord[3] , grid_span , grid_size ) ;
for( x_step = max( ( x - steps ) , 0 ) ; x_step <= min( ( x + steps ) , ( grid_size - 1 ) ) ; x_step ++ ) {
x_centre = gcentre( x_step , grid_span , grid_size ) ;
for( y_step = max( ( y - steps ) , 0 ) ; y_step <= min( ( y + steps ) , ( grid_size - 1 ) ) ; y_step ++ ) {
y_centre = gcentre( y_step , grid_span , grid_size ) ;
for( z_step = max( ( z - steps ) , 0 ) ; z_step <= min( ( z + steps ) , ( grid_size - 1 ) ) ; z_step ++ ) {
z_centre = gcentre( z_step , grid_span , grid_size ) ;
if( pythagoras( This_Structure.Residue[residue].Atom[atom].coord[1] , This_Structure.Residue[residue].Atom[atom].coord[2] , This_Structure.Residue[residue].Atom[atom].coord[3] , x_centre , y_centre , z_centre ) < distance ) grid[gaddress(x_step,y_step,z_step,grid_size)] = (float)1 ;
}
}
}
}
}
/************/
return ;
}
static int
vips_smartcrop_attention( VipsSmartcrop *smartcrop,
VipsImage *in, int *left, int *top )
{
/* From smartcrop.js.
*/
static double skin_vector[] = {-0.78, -0.57, -0.44};
static double ones[] = {1.0, 1.0, 1.0};
VipsImage **t = (VipsImage **)
vips_object_local_array( VIPS_OBJECT( smartcrop ), 24 );
double hscale;
double vscale;
double sigma;
double max;
int x_pos;
int y_pos;
/* The size we shrink to gives the precision with which we can place
* the crop
*/
hscale = 32.0 / in->Xsize;
vscale = 32.0 / in->Ysize;
sigma = VIPS_MAX( sqrt( pow( smartcrop->width * hscale, 2 ) +
pow( smartcrop->height * vscale, 2 ) ) / 10, 1.0 );
if ( vips_resize( in, &t[17], hscale,
"vscale", vscale,
NULL ) )
return( -1 );
/* Simple edge detect.
*/
if( !(t[21] = vips_image_new_matrixv( 3, 3,
0.0, -1.0, 0.0,
-1.0, 4.0, -1.0,
0.0, -1.0, 0.0 )) )
return( -1 );
/* Convert to XYZ and just use the first three bands.
*/
if( vips_colourspace( t[17], &t[0], VIPS_INTERPRETATION_XYZ, NULL ) ||
vips_extract_band( t[0], &t[1], 0, "n", 3, NULL ) )
return( -1 );
/* Edge detect on Y.
*/
if( vips_extract_band( t[1], &t[2], 1, NULL ) ||
vips_conv( t[2], &t[3], t[21],
"precision", VIPS_PRECISION_INTEGER,
NULL ) ||
vips_linear1( t[3], &t[4], 5.0, 0.0, NULL ) ||
vips_abs( t[4], &t[14], NULL ) )
return( -1 );
/* Look for skin colours. Taken from smartcrop.js.
*/
if(
/* Normalise to magnitude of colour in XYZ.
*/
pythagoras( smartcrop, t[1], &t[5] ) ||
vips_divide( t[1], t[5], &t[6], NULL ) ||
/* Distance from skin point.
*/
vips_linear( t[6], &t[7], ones, skin_vector, 3, NULL ) ||
pythagoras( smartcrop, t[7], &t[8] ) ||
/* Rescale to 100 - 0 score.
*/
vips_linear1( t[8], &t[9], -100.0, 100.0, NULL ) ||
/* Ignore dark areas.
*/
vips_more_const1( t[2], &t[10], 5.0, NULL ) ||
!(t[11] = vips_image_new_from_image1( t[10], 0.0 )) ||
vips_ifthenelse( t[10], t[9], t[11], &t[15], NULL ) )
return( -1 );
/* Look for saturated areas.
*/
if( vips_colourspace( t[1], &t[12],
VIPS_INTERPRETATION_LAB, NULL ) ||
vips_extract_band( t[12], &t[13], 1, NULL ) ||
vips_ifthenelse( t[10], t[13], t[11], &t[16], NULL ) )
return( -1 );
/* Sum, blur and find maxpos.
*
* The amount of blur is related to the size of the crop
* area: how large an area we want to consider for the scoring
* function.
*/
if( vips_sum( &t[14], &t[18], 3, NULL ) ||
vips_gaussblur( t[18], &t[19], sigma, NULL ) ||
vips_max( t[19], &max, "x", &x_pos, "y", &y_pos, NULL ) )
return( -1 );
/* Centre the crop over the max.
*/
*left = VIPS_CLIP( 0,
x_pos / hscale - smartcrop->width / 2,
in->Xsize - smartcrop->width );
*top = VIPS_CLIP( 0,
y_pos / vscale - smartcrop->height / 2,
in->Ysize - smartcrop->height );
return( 0 );
}
void drvIDRAW::print_coords()
{
unsigned int pathelts = numberOfElementsInPath();
bool closed; // True if shape is closed
bool curved; // True if shape is curved
const Point *firstpoint; // First and last points in shape
const Point *lastpoint;
unsigned int totalpoints; // Total number of points in shape
const Point dummypoint(-123.456f, -789.101112f); // Used to help eliminate duplicates
unsigned int i, j;
// First, try to figure out what type of shape we have
closed = false;
curved = false;
for (i = 0; i < pathelts; i++) {
if (pathElement(i).getType() == curveto)
curved = true;
else if (pathElement(i).getType() == closepath)
closed = true;
}
const Point **pointlist = new const Point *[pathelts * 3]; // List of points
// Allocate a conservative amount
assert(pointlist != NIL);
firstpoint = NIL;
lastpoint = &dummypoint;
totalpoints = 0;
for (i = 0; i < pathelts; i++) {
const basedrawingelement & pelt = pathElement(i);
if ((pelt.getType() == moveto || pelt.getType() == lineto) &&
!(pelt.getPoint(0) == *lastpoint))
lastpoint = pointlist[totalpoints++] = &pelt.getPoint(0);
else if (pelt.getType() == curveto)
for (j = 0; j < 3; j++)
lastpoint = pointlist[totalpoints++] = &pelt.getPoint(j);
}
if (totalpoints) {
firstpoint = pointlist[0];
if (firstpoint->x_ == lastpoint->x_ && firstpoint->y_ == lastpoint->y_)
closed = true;
// Find points on the curve for curved lines
if (curved) {
const unsigned int pt_per_cp = 5; // PostScript points per control point
const unsigned int min_innerpoints = 2; // Minimum # of points to add
unsigned int innerpoints; // Number of points to add
unsigned int newtotalpoints = 0; // Number of points in curve
// ASSUMPTION: Curve is moveto+curveto+curveto+curveto+...
// List of points on curve
const Point **newpointlist = new const Point *[pathelts * 3000 / pt_per_cp]; // Allocate a conservative amount
assert(newpointlist != NIL);
for (i = 0; i < totalpoints - 3; i += 3) {
const float x0 = pointlist[i]->x_;
const float y0 = pointlist[i]->y_;
const float x1 = pointlist[i + 1]->x_;
const float y1 = pointlist[i + 1]->y_;
const float x2 = pointlist[i + 2]->x_;
const float y2 = pointlist[i + 2]->y_;
const float x3 = pointlist[i + 3]->x_;
const float y3 = pointlist[i + 3]->y_;
const float cx = (x1 - x0) * 3;
const float cy = (y1 - y0) * 3;
const float bx = (x2 - x1) * 3 - cx;
const float by = (y2 - y1) * 3 - cy;
const float ax = x3 - x0 - cx - bx;
const float ay = y3 - y0 - cy - by;
// Longer lines get more control points
innerpoints =(unsigned int) (
pythagoras((y1 - y0),(x1 - x0) ) +
pythagoras((y2 - y1),(x2 - x1) ) +
pythagoras((y3 - y2),(x3 - x2) ) ) / pt_per_cp;
if (innerpoints < min_innerpoints)
innerpoints = min_innerpoints;
// Add points to the list
ADDPOINT(x0, y0);
for (j = 1; j <= innerpoints; j++) {
const float t = (float) j / (float) innerpoints;
const float newx = (((ax * t) + bx) * t + cx) * t + x0;
const float newy = (((ay * t) + by) * t + cy) * t + y0;
ADDPOINT(newx, newy);
}
ADDPOINT(x3, y3);
}
delete[]pointlist;
pointlist = newpointlist;
totalpoints = newtotalpoints;
}
// Straight lines, not closed
if (!closed && !curved) {
if (totalpoints == 2) { // Special case for single line
print_header("Line");
outf << "%I" << endl;
outf << iscale(firstpoint->x_) << ' ' << iscale(firstpoint->y_) << ' ';
outf << iscale(lastpoint->x_) << ' ' << iscale(lastpoint->y_) << ' ';
outf << "Line" << endl;
outf << "%I 1" << endl;
outf << "End" << endl << endl;
} else { // Otherwise, output a multiline
print_header("MLine"); // (Should have a special case for Rect)
outf << "%I " << totalpoints << endl;
for (i = 0; i < totalpoints; i++) {
outf << iscale(pointlist[i]->x_) << ' ';
outf << iscale(pointlist[i]->y_) << endl;
}
outf << totalpoints << " MLine" << endl;
outf << "%I 1" << endl;
outf << "End" << endl << endl;
}
}
// Straight lines, closed */
if (closed && !curved) {
unsigned int numpoints;
numpoints = totalpoints == 1 ? 1 : totalpoints - 1;
print_header("Poly"); // Output a polygon
outf << "%I " << numpoints << endl;
for (i = 0; i < numpoints; i++) {
outf << iscale(pointlist[i]->x_) << ' ';
outf << iscale(pointlist[i]->y_) << endl;
}
outf << numpoints << " Poly" << endl;
outf << "End" << endl << endl;
}
// Curved lines, not closed
if (!closed && curved) {
print_header("BSpl"); // Output a B-spline
outf << "%I " << totalpoints << endl;
for (i = 0; i < totalpoints; i++) {
outf << iscale(pointlist[i]->x_) << ' ';
outf << iscale(pointlist[i]->y_) << endl;
}
outf << totalpoints << " BSpl" << endl;
outf << "%I 1" << endl;
outf << "End" << endl << endl;
}
// Curved lines, closed
if (closed && curved) {
unsigned int numpoints;
numpoints = totalpoints == 1 ? 1 : totalpoints - 1;
print_header("CBSpl"); // Output a closed B-spline
outf << "%I " << numpoints << endl;
for (i = 0; i < numpoints; i++) {
outf << iscale(pointlist[i]->x_) << ' ';
outf << iscale(pointlist[i]->y_) << endl;
}
outf << numpoints << " CBSpl" << endl;
outf << "End" << endl << endl;
}
if (curved) {
//
// in this case we have created the pointlist newly with Points on the heap
//
if (pointlist)
for (unsigned int pindex = 0; pindex < totalpoints; pindex++) {
//cout << "pindex / totalpoints " << pindex << " " << totalpoints << " " << pointlist[pindex]->x_ << " " << pointlist[pindex]->y_ << " " << pointlist[pindex]<< endl;
#if defined (_MSC_VER) && (_MSC_VER < 1100)
// MSVC < 6 needs cast here
delete (Point *) (pointlist[pindex]);
#else
delete (pointlist[pindex]);
#endif
}
}
}
delete[]pointlist;
}
void electric_field( struct Structure This_Structure , float grid_span , int grid_size , float *grid ) {
/************/
/* Counters */
int residue , atom ;
/* Co-ordinates */
int x , y , z ;
float x_centre , y_centre , z_centre ;
/* Variables */
float distance ;
float phi , epsilon ;
/************/
for( x = 0 ; x < grid_size ; x ++ ) {
for( y = 0 ; y < grid_size ; y ++ ) {
for( z = 0 ; z < grid_size ; z ++ ) {
grid[gaddress(x,y,z,grid_size)] = (double)0 ;
}
}
}
/************/
setvbuf( stdout , (char *)NULL , _IONBF , 0 ) ;
printf( " electric field calculations ( one dot / grid sheet ) " ) ;
for( x = 0 ; x < grid_size ; x ++ ) {
printf( "." ) ;
x_centre = gcentre( x , grid_span , grid_size ) ;
for( y = 0 ; y < grid_size ; y ++ ) {
y_centre = gcentre( y , grid_span , grid_size ) ;
for( z = 0 ; z < grid_size ; z ++ ) {
z_centre = gcentre( z , grid_span , grid_size ) ;
phi = 0 ;
for( residue = 1 ; residue <= This_Structure.length ; residue ++ ) {
for( atom = 1 ; atom <= This_Structure.Residue[residue].size ; atom ++ ) {
if( This_Structure.Residue[residue].Atom[atom].charge != 0 ) {
distance = pythagoras( This_Structure.Residue[residue].Atom[atom].coord[1] , This_Structure.Residue[residue].Atom[atom].coord[2] , This_Structure.Residue[residue].Atom[atom].coord[3] , x_centre , y_centre , z_centre ) ;
if( distance < 2.0 ) distance = 2.0 ;
if( distance >= 2.0 ) {
if( distance >= 8.0 ) {
epsilon = 80 ;
} else {
if( distance <= 6.0 ) {
epsilon = 4 ;
} else {
epsilon = ( 38 * distance ) - 224 ;
}
}
phi += ( This_Structure.Residue[residue].Atom[atom].charge / ( epsilon * distance ) ) ;
}
}
}
}
grid[gaddress(x,y,z,grid_size)] = (double)phi ;
}
}
}
printf( "\n" ) ;
/************/
return ;
}
