void shoot(){
cleararea(133,298,227,392);
int xPos = calculateX(135+degree, calculateY(135+degree));
int yPos;
if (xPos == 750){
yPos = calculateIfXMax(135+degree, calculateY(135+degree));
}
else {
yPos = 20;
}
draw_line(135,390,xPos,yPos,pixel_color(200,0,0,&vinfo));
usleep(10000);
clearscreen();
target(degree);
}
/**
* Convert the spectrum at the given index on the input workspace
* and place the output in the pre-allocated output workspace
* @param index Index on the input & output workspaces giving the spectrum to
* convert
*/
bool ConvertToYSpace::convert(const size_t index) {
try {
DetectorParams detPar = getDetectorParameters(m_inputWS, index);
const double v1 = std::sqrt(detPar.efixed / MASS_TO_MEV);
const double k1 = std::sqrt(detPar.efixed /
PhysicalConstants::E_mev_toNeutronWavenumberSq);
auto &outX = m_outputWS->dataX(index);
auto &outY = m_outputWS->dataY(index);
auto &outE = m_outputWS->dataE(index);
const auto &inX = m_inputWS->readX(index);
const auto &inY = m_inputWS->readY(index);
const auto &inE = m_inputWS->readE(index);
// The t->y mapping flips the order of the axis so we need to reverse it to
// have a monotonically
// increasing axis
const size_t npts = inY.size();
for (size_t j = 0; j < npts; ++j) {
double ys(0.0), qs(0.0), ei(0.0);
calculateY(ys, qs, ei, m_mass, inX[j] * 1e-06, k1, v1, detPar);
const size_t outIndex = (npts - j - 1);
outX[outIndex] = ys;
const double prefactor = qs / pow(ei, 0.1);
outY[outIndex] = prefactor * inY[j];
outE[outIndex] = prefactor * inE[j];
}
return true;
} catch (Exception::NotFoundError &) {
return false;
}
}
GLPoint calculateNextPoint(const GLPoint& current)
{
GLPoint next;
float t = calculateY(current.x);
if(fabs(current.y - t) < FLT_EPSILON)
{
next.y = current.y;
next.x = next.y;
}
else
{
next.x = current.x;
next.y = calculateY(next.x);
}
// cout<<next.x<<"*"<<next.y<<endl;
return next;
}
double Neiron::calculateWeights(double *X, int yNum)
{
double y = calculateY(X);
double Y = X[enterCount + yNum];
double d = Y - y;
double v = velocity;
weight[0] += v * d * 1;
for (int i = 0; i < enterCount; i ++) {
weight[i + 1] += v * d * X[i];
}
return y;
}
int isExploded() {
int x2 = 20;
int y2 = calculateX(135+degree, calculateY(135+degree));
if ((isShoot == 1) && (y2 >= coor_y && y2 <=coor_y+120))
return 1;
else {
isShoot = 0;
return 0;
}
/*int x2 = 20; // harusnya ini titik tembakan
int y2 = calculateX(135+degree, calculateY(135+degree)); // harusnya ini titik tembakan
if((coor_y >= y2 && coor_y <=y2+120) && (coor_x >= x2 && coor_x <= x2+70)) return 1;
else return 0;
*/
}
void drawArc()
{
glColor3f(1.0,0,0);
glPointSize(1);
glBegin(GL_POINTS);
float f = 1.0f/1000;
for(int i = 0;i<1000;i++)
{
float x = f*i;
float y = calculateY(x);
glVertex2f(x,y);
}
glEnd();
glBegin(GL_LINES);
glVertex2f(0.0f,0.0f);
glVertex2f(1.0f,1.0f);
glEnd();
}
void removeshoot(){
draw_line(135,390,calculateX(135+degree, calculateY(135+degree)),20,pixel_color(224,248,255,&vinfo));
}
void target(int degree){
cleararea(133,298,227,389);
int yPos = calculateY(135+degree);
if (degree >= 1 || degree <=87)
directDraw(135,390,135+degree,yPos,pixel_color(0,200,0,&vinfo));
}
/**
* \ingroup LALInspiralBank_h
* \author Hanna, C. R. and Owen, B. J.
* \brief This function creates a bank of BCVSpin templates to search for precessing binaries.
*
* ### Algorithm ###
*
* The code checks <tt>coarseIn-\>mMin</tt> to determine whether the limits on
* the target region are in terms of masses or phenomenological parameters.
* A positive value indicates that mass limits are being used.
*
* If mass limits are used, the target region of parameter space is a
* distorted box in the coordinates \f$(x=\psi_0, y=\psi_3, z=\beta)\f$. The
* metric at high values of \f$\beta\f$ is constant. It is convenient to rotate
* to coordinates \f$(x',y',z')\f$ which lie along eigenvectors of the metric.
*
* The algorithm first draws a rectilinear box in the primed coordinates
* which includes the target region, then steps through along the
* directions of the primed coordinates. At each point it tests if the
* point lies within the target region. If the point is inside the target
* region, the algorithm adds a template to the linked list. If not, it
* continues through the box containing the target region.
*
* The tiling is done with a body-centered cubic lattice. People usually
* solve the non-overlapping bcc problem rather than the overlapping one
* here, so it's worth mentioning how we do it. I don't have time to stick
* in the 3D figures you need to show it properly, but you can figure out
* the spacing by finding the smallest sphere that contains the
* Wigner-Seitz cell. When you do that you find that the lattice constant
* (spacing between templates in the plane, in proper distance) is
* \f$(4/3)\sqrt{2\mu}\f$. So the coordinate spacing is that divided by the
* square root of the corresponding eigenvalue of the metric. (The vertical
* spacing in the bcc lattice is multiplied by a further 1/2.)
*
* If \f$(\psi_0, \psi_3, \beta)\f$ limits are used, the tiling is done in the
* given box with a bcc lattice.
*
* ### Notes ###
*
* Currently we use a static function for the metric based on an
* approximation that is good only for large \f$\beta\f$. We should update it
* and put it out in the LAL namespace.
*
* The metric relies on approximations that make it valid only for a binary
* system with a total mass \f$<15M\odot\f$ where the larger body's minimum mass
* is at least twice the smaller body's maximum mass. If the parameter
* range is specified with physical parameters rather than the
* phenomenological parameters \f$(\psi_0, \psi_3, \beta)\f$ then using mass
* values that violate these conditions will result in an error message.
*
*/
void
LALInspiralSpinBank(
LALStatus *status,
SnglInspiralTable **tiles,
INT4 *ntiles,
InspiralCoarseBankIn *coarseIn
)
{
SnglInspiralTable *tmplt = NULL; /* loop counter */
REAL4Array *metric = NULL; /* parameter-space metric */
UINT4Vector *metricDimensions = NULL; /* contains the dimension of metric */
REAL4Vector *eigenval = NULL; /* eigenvalues of metric */
InspiralMomentsEtc moments; /* Added for LALGetInspiralMoments() */
InspiralTemplate inspiralTemplate; /* Added for LALGetInspiralMoments() */
REAL4 x, y, z; /* psi0, psi3, beta coordinates */
REAL4 x0, myy0, z0; /* minimum values of x, y, z */
REAL4 x1, myy1, z1; /* maximum values of x, y, z */
REAL4 xp, yp, zp; /* metric eigenvector coordinates */
REAL4 xp0, yp0, UNUSED zp0; /* minimum values of xp, yp, zp */
REAL4 xp1, yp1, zp1; /* maximum values of xp, yp, zp */
REAL4 dxp, dyp, dzp; /* step sizes in xp, yp, zp */
REAL4 theta; /* angle of rotation for xp and yp */
REAL4 m1Min=0, m1Max=0; /* range of m1 to search */
REAL4 m2Min=0, m2Max=0; /* range of m2 to search */
REAL4 f0 = -1; /* frequency of minimum of noise curve */
INT2 bccFlag = 0; /* determines offset for bcc tiling */
INT4 cnt = 0; /* loop counter set to value of ntiles */
REAL4 shf0 = 1; /* used to find minimum of shf */
BOOLEAN havePsi; /* are we using phenom parameters? */
/* Set up status pointer. */
INITSTATUS(status);
ATTATCHSTATUSPTR( status );
ASSERT( coarseIn, status, LALINSPIRALBANKH_ENULL,
LALINSPIRALBANKH_MSGENULL );
/* Check that minimal match is OK. */
ASSERT( coarseIn->mmCoarse > 0, status, LALINSPIRALBANKH_ECHOICE,
LALINSPIRALBANKH_MSGECHOICE );
/* Sanity check parameter bounds. */
if( coarseIn->mMin > 0 )
{
ASSERT( coarseIn->MMax > 0, status, LALINSPIRALBANKH_ECHOICE,
LALINSPIRALBANKH_MSGECHOICE );
ASSERT( coarseIn->MMax > 2*coarseIn->mMin, status,
LALINSPIRALBANKH_ECHOICE, LALINSPIRALBANKH_MSGECHOICE );
havePsi = 0;
}
/* Sanity check phenomenological parameter bounds. */
else
{
ASSERT( coarseIn->psi0Min > 0, status, LALINSPIRALBANKH_ECHOICE,
LALINSPIRALBANKH_MSGECHOICE );
ASSERT( coarseIn->psi0Max > coarseIn->psi0Min, status,
LALINSPIRALBANKH_ECHOICE, LALINSPIRALBANKH_MSGECHOICE );
ASSERT( coarseIn->psi3Min < 0, status, LALINSPIRALBANKH_ECHOICE,
LALINSPIRALBANKH_MSGECHOICE );
ASSERT( coarseIn->psi3Max > coarseIn->psi3Min, status,
LALINSPIRALBANKH_ECHOICE, LALINSPIRALBANKH_MSGECHOICE );
ASSERT( coarseIn->betaMax > coarseIn->betaMin, status,
LALINSPIRALBANKH_ECHOICE, LALINSPIRALBANKH_MSGECHOICE );
havePsi = 1;
}
/* Check that noise curve exists. */
ASSERT( coarseIn->shf.data, status, LALINSPIRALBANKH_ENULL,
LALINSPIRALBANKH_MSGENULL );
ASSERT( coarseIn->shf.data->data, status, LALINSPIRALBANKH_ENULL,
LALINSPIRALBANKH_MSGENULL );
/* Allocate memory for 3x3 parameter-space metric & eigenvalues. */
LALU4CreateVector( status->statusPtr, &metricDimensions, (UINT4) 2 );
BEGINFAIL(status)
cleanup(status->statusPtr, &metric, &metricDimensions, &eigenval, *tiles, tmplt, ntiles);
ENDFAIL(status);
metricDimensions->data[0] = 3;
metricDimensions->data[1] = 3;
LALSCreateArray( status->statusPtr, &metric, metricDimensions );
BEGINFAIL(status)
cleanup(status->statusPtr,&metric,&metricDimensions,&eigenval,*tiles,tmplt, ntiles);
ENDFAIL(status);
eigenval = NULL;
LALSCreateVector( status->statusPtr, &eigenval, 3 );
BEGINFAIL(status)
cleanup(status->statusPtr,&metric, &metricDimensions,&eigenval,*tiles,tmplt, ntiles);
ENDFAIL(status);
/* Set f0 to frequency of minimum of noise curve. */
for( cnt = 0; cnt < (INT4) coarseIn->shf.data->length; cnt++ )
{
if( coarseIn->shf.data->data[cnt] > 0 && coarseIn->shf.data->data[cnt] <
shf0 )
{
f0 = (REAL4) coarseIn->shf.deltaF * cnt;
shf0 = coarseIn->shf.data->data[cnt];
}
}
/* Compute noise moments. */
inspiralTemplate.fLower = coarseIn->fLower;
inspiralTemplate.fCutoff = coarseIn->fUpper;
LALGetInspiralMoments( status->statusPtr, &moments, &(coarseIn->shf),
&inspiralTemplate );
BEGINFAIL(status)
cleanup(status->statusPtr,&metric,&metricDimensions,&eigenval,*tiles,tmplt,ntiles);
ENDFAIL(status);
/* Find the metric. */
LALInspiralSpinBankMetric(status->statusPtr, metric, &moments, &inspiralTemplate, &f0);
BEGINFAIL(status)
cleanup(status->statusPtr,&metric,&metricDimensions,&eigenval,*tiles,tmplt, ntiles);
ENDFAIL(status);
/* Find eigenvalues and eigenvectors. */
LALSSymmetricEigenVectors( status->statusPtr, eigenval, metric );
BEGINFAIL(status)
cleanup(status->statusPtr,&metric, &metricDimensions,&eigenval,*tiles,tmplt, ntiles);
ENDFAIL(status);
/* Allocate first template, which will remain blank. */
*tiles = tmplt = (SnglInspiralTable *) LALCalloc( 1,
sizeof( SnglInspiralTable ) );
if ( *tiles == NULL )
{
cleanup( status->statusPtr, &metric, &metricDimensions, &eigenval,
*tiles, tmplt, ntiles);
ABORT( status, LALINSPIRALBANKH_EMEM, LALINSPIRALBANKH_MSGEMEM );
}
*ntiles = 0;
/* Set stepsizes from eigenvalues and angle from eigenvectors. */
if( eigenval->data[0] <= 0 || eigenval->data[1] <=0 || eigenval->data[2]
<= 0 )
{
ABORT(status, LALINSPIRALBANKH_ECHOICE, LALINSPIRALBANKH_MSGECHOICE);
}
dxp = 1.333333*sqrt(2*(1-coarseIn->mmCoarse)/eigenval->data[0]);
dyp = 1.333333*sqrt(2*(1-coarseIn->mmCoarse)/eigenval->data[1]);
dzp = 0.6666667*sqrt(2*(1-coarseIn->mmCoarse)/eigenval->data[2]);
theta = atan2( -metric->data[3], -metric->data[0] );
printf( "theta is %e\n", theta );
/* If target region is given in terms of masses... */
if ( ! havePsi )
{
/* Hardcode mass range on higher mass for the moment. */
m2Min = coarseIn->mMin*LAL_MTSUN_SI;
m2Max = coarseIn->MMax*LAL_MTSUN_SI/2;
m1Min = 2.0*m2Max;
m1Max = 15.0*LAL_MTSUN_SI - m2Max;
/* Set box on unprimed phenom coordinates including region. */
x0 = 0.9*(3.0/128) / (pow(LAL_PI*f0*(m1Max+m2Max),1.666667)
*(m1Max*m2Max/pow(m1Max+m2Max,2)));
myy0 = 1.1*(-.375*LAL_PI) / (pow(LAL_PI*f0*(m1Max+m2Min),0.6666667)*(m1Max*m2Min/pow(m1Max+m2Min,2)));
z0 = 0;
x1 = 1.1*(3.0/128) / (pow(LAL_PI*f0*(m1Min+m2Min),1.666667)*(m1Min*m2Min/pow(m1Min+m2Min,2)));
myy1 = .9*(-.375*LAL_PI) / (pow(LAL_PI*f0*(m1Min+m2Max),0.6666667)*(m1Min*m2Max/pow(m1Min+m2Max,2)));
z1 = 3.8* LAL_PI/29.961432 * (1+0.75*m2Max/m1Min) * (m1Max/m2Min) * pow(LAL_MTSUN_SI*100.0/(m1Min+m2Min), 0.6666667);
}
/* Target region is given in terms of psi etc (unprimed). */
else
{
/* Rescale to dimensionless parameters used internally. */
x0 = coarseIn->psi0Min / pow( f0, 5./3 );
x1 = coarseIn->psi0Max / pow( f0, 5./3 );
myy0 = coarseIn->psi3Min / pow( f0, 2./3 );
myy1 = coarseIn->psi3Max / pow( f0, 2./3 );
z0 = coarseIn->betaMin / pow( f0, 2./3 );
z1 = coarseIn->betaMax / pow( f0, 2./3 );
}
/* Set boundaries of bigger box in primed (eigen) coordinates. */
xp0 = x0 + sin(theta)*sin(theta) * (x1 - x0);
yp0 = myy0 - cos(theta)*sin(theta) * (x1 - x0);
yp1 = sin(theta) * (x1 - x0) + cos(theta) * (myy1 - myy0);
xp1 = sin(theta) * (myy1 - myy0) + cos(theta) * (x1 - x0);
zp0 = z0;
zp1 = z1;
/* This loop generates the template bank. */
for (zp = 0; zp <= zp1; zp += dzp)
{
bccFlag++;
for (yp = 0; yp<= yp1; yp += dyp)
{
for (xp = 0; xp <= xp1; xp += dxp)
{
/* If the point is in the target region, allocate a template. */
x = calculateX(0, xp0, xp, dxp, yp, dyp, bccFlag, theta);
y = calculateY(0, yp0, xp, dxp, yp, dyp, bccFlag, theta);
z = calculateZ(0, zp, dzp);
if( ( havePsi && inPsiRegion( x, y, z, coarseIn, f0 ) )
|| ( ! havePsi && test(x,y,z,m1Min,m1Max,m2Min,m2Max,f0) ) )
{
allocate( x, y, z, f0, &tmplt, ntiles, havePsi );
if( tmplt == NULL )
{
cleanup(status->statusPtr,&metric,&metricDimensions,&eigenval,*tiles,tmplt,ntiles);
ABORT(status, LALINSPIRALBANKH_EMEM, LALINSPIRALBANKH_MSGEMEM);
}
}
/* If dx behind is not in region, try dx/2 behind. */
x = calculateX(-1, xp0, xp, dxp, yp, dyp, bccFlag, theta);
if( ( havePsi && ! inPsiRegion( x, y, z, coarseIn, f0 ) )
|| ( ! havePsi && ! test(x,y,z,m1Min,m1Max,m2Min,m2Max,f0) ) )
{
x = calculateX(-0.5, xp0, xp, dxp, yp, dyp, bccFlag, theta);
if( ( havePsi && inPsiRegion( x, y, z, coarseIn, f0 ) )
|| ( ! havePsi && test(x,y,z,m1Min,m1Max,m2Min,m2Max,f0) ) )
{
allocate( x, y, z, f0, &tmplt, ntiles, havePsi );
if( tmplt == NULL )
{
cleanup(status->statusPtr,&metric,&metricDimensions,&eigenval,*tiles,tmplt,ntiles);
ABORT(status, LALINSPIRALBANKH_EMEM, LALINSPIRALBANKH_MSGEMEM);
}
}
}
/* If dy behind is not in region, try dy/2 behind. */
x = calculateX(0, xp0, xp, dxp, yp, dyp, bccFlag, theta);
y = calculateY(-1, yp0, xp, dxp, yp, dyp, bccFlag, theta);
if( ( havePsi && ! inPsiRegion( x, y, z, coarseIn, f0 ) )
|| ( ! havePsi && ! test(x,y,z,m1Min,m1Max,m2Min,m2Max,f0) ) )
{
y = calculateY(-0.5, yp0, xp, dxp, yp, dyp, bccFlag, theta);
if( ( havePsi && inPsiRegion( x, y, z, coarseIn, f0 ) )
|| ( ! havePsi && test(x,y,z,m1Min,m1Max,m2Min,m2Max,f0) ) )
{
allocate( x, y, z, f0, &tmplt, ntiles, havePsi );
if (!tmplt){
cleanup(status->statusPtr,&metric,&metricDimensions,&eigenval,*tiles,tmplt,ntiles);
ABORT(status, LALINSPIRALBANKH_EMEM, LALINSPIRALBANKH_MSGEMEM);
}
}
}
/* If dz behind is not in region, try dz/2 behind. */
y = calculateY(0, yp0, xp, dxp, yp, dyp, (bccFlag+1), theta);
z = calculateZ(-1, zp, dzp);
if( ( havePsi && ! inPsiRegion( x, y, z, coarseIn, f0 ) )
|| ( ! havePsi && ! test(x,y,z,m1Min,m1Max,m2Min,m2Max,f0) ) )
{
z = calculateZ(-0.5, zp, dzp);
if( ( havePsi && inPsiRegion( x, y, z, coarseIn, f0 ) )
|| ( ! havePsi && test(x,y,z,m1Min,m1Max,m2Min,m2Max,f0) ) )
{
allocate( x, y, z, f0, &tmplt, ntiles, havePsi );
if (!tmplt){
cleanup(status->statusPtr,&metric,&metricDimensions,&eigenval,*tiles,tmplt,ntiles);
ABORT(status, LALINSPIRALBANKH_EMEM, LALINSPIRALBANKH_MSGEMEM);
}
}
}
/* If dx ahead is not in region, try dx/2 ahead. */
x = calculateX(1, xp0, xp, dxp, yp, dyp, bccFlag, theta);
y = calculateY(0, yp0, xp, dxp, yp, dyp, (bccFlag+1), theta);
z = calculateZ(0, zp, dzp);
if( ( havePsi && ! inPsiRegion( x, y, z, coarseIn, f0 ) )
|| ( ! havePsi && ! test(x,y,z,m1Min,m1Max,m2Min,m2Max,f0) ) )
{
x = calculateX(0.5, xp0, xp, dxp, yp, dyp, bccFlag, theta);
if( ( havePsi && inPsiRegion( x, y, z, coarseIn, f0 ) )
|| ( ! havePsi && test(x,y,z,m1Min,m1Max,m2Min,m2Max,f0) ) )
{
allocate( x, y, z, f0, &tmplt, ntiles, havePsi );
if (!tmplt){
cleanup(status->statusPtr,&metric,&metricDimensions,&eigenval,*tiles,tmplt,ntiles);
ABORT(status, LALINSPIRALBANKH_EMEM, LALINSPIRALBANKH_MSGEMEM);
}
}
}
/* If dy ahead is not in region, try dy/2 ahead. */
x = calculateX(0, xp0, xp, dxp, yp, dyp, bccFlag, theta);
y = calculateY(1, yp0, xp, dxp, yp, dyp, bccFlag, theta);
if( ( havePsi && ! inPsiRegion( x, y, z, coarseIn, f0 ) )
|| ( ! havePsi && ! test(x,y,z,m1Min,m1Max,m2Min,m2Max,f0) ) )
{
y = calculateY(0.5, yp0, xp, dxp, yp, dyp, bccFlag, theta);
if( ( havePsi && inPsiRegion( x, y, z, coarseIn, f0 ) )
|| ( ! havePsi && test(x,y,z,m1Min,m1Max,m2Min,m2Max,f0) ) )
{
allocate( x, y, z, f0, &tmplt, ntiles, havePsi );
if (!tmplt){
cleanup(status->statusPtr,&metric,&metricDimensions,&eigenval,*tiles,tmplt,ntiles);
ABORT(status, LALINSPIRALBANKH_EMEM, LALINSPIRALBANKH_MSGEMEM);
}
}
}
/* If dz ahead is not in region, try dz/2 ahead. */
y = calculateY(0, yp0, xp, dxp, yp, dyp, (bccFlag+1), theta);
z = calculateZ(1, zp, dzp);
if( ( havePsi && ! inPsiRegion( x, y, z, coarseIn, f0 ) )
|| ( ! havePsi && ! test(x,y,z,m1Min,m1Max,m2Min,m2Max,f0) ) )
{
z = calculateZ(0.5, zp, dzp);
if( ( havePsi && inPsiRegion( x, y, z, coarseIn, f0 ) )
|| ( ! havePsi && test(x,y,z,m1Min,m1Max,m2Min,m2Max,f0) ) )
{
allocate( x, y, z, f0, &tmplt, ntiles, havePsi );
if (!tmplt){
cleanup(status->statusPtr,&metric,&metricDimensions,&eigenval,*tiles,tmplt,ntiles);
ABORT(status, LALINSPIRALBANKH_EMEM, LALINSPIRALBANKH_MSGEMEM);
}
}
}
} /* for (zp...) */
} /* for (yp...) */
} /* for (zp...) */
/* Trim the first template, which was left blank. */
tmplt = (*tiles)->next;
LALFree( *tiles );
*tiles = tmplt;
/* What if no templates were allocated? ABORT */
if (*tiles == NULL)
{
cleanup(status->statusPtr,&metric,&metricDimensions,&eigenval,*tiles,tmplt,ntiles);
ABORT(status, INSPIRALSPINBANKC_ENOTILES, INSPIRALSPINBANKC_MSGENOTILES);
}
/* free memory allocated for the vectors and arrays */
cleanup(status->statusPtr,&metric,&metricDimensions,&eigenval,NULL,NULL,&cnt);
DETATCHSTATUSPTR( status );
RETURN( status );
} /* LALInspiralSpinBank() */
int main(int argc, char** argv){
if(argc < 2){
printf("pass in the file name as the first argument\n");
std::cin.get();
exit(1);
}
IplImage* img = cvLoadImage(argv[1], CV_LOAD_IMAGE_GRAYSCALE);
cvNamedWindow("MIT Road Paint Detector", CV_WINDOW_AUTOSIZE);
cvSetMouseCallback("MIT Road Paint Detector", mouseCallbackFunc);
/* camera matrix set up */
Camera camera(FOCAL_LENGTH, 640, 480);
CvMat *P = camera.getP();
CvPoint2D32f point = camera.imageToGroundPlane(cvPoint(1,1));
printf("x = %f, %f, \n", point.x, point.y);
float Y;
int row, col, j, k, width;
std::vector<float> kernel;
std::vector<float> out(640);
std::vector<int> in(640);
Convolution convolution;
FILE *fp;
for (row = 0; row < img->height; row++) {
Y = calculateY(P, row);
width = calculateWidthInPixels(P, Y);
if (width < ONE_PIXEL) {
width = 0;
}
#if defined(DEBUG)
if (row == 374) {
fp = fopen("input.txt", "wt");
fprintf(fp, "#\t X\t Y\n");
}
#endif
for (col = 0; col < img->width; col++) {
CvScalar scalar = cvGet2D(img, row, col);
in[col] = scalar.val[0];
#if defined(DEBUG)
if (row == 374) {
fprintf(fp, "\t %d\t %d\t\n", col, in[col]);
}
#endif
}
#if defined(DEBUG)
if (row == 374) {
fclose(fp);
}
#endif
//find the kernel only if only there is a width
if (width > 0) {
convolution.kernel1D(width, kernel);
convolution.convolve1D(in, kernel, out);
#if defined(DEBUG)
if (row == 374) {
//convolution result
fp = fopen("convolution.txt", "wt");
fprintf(fp, "#\t X\t Y\n");
for (col = 0; col < img->width; col++) {
fprintf(fp, "\t %d\t %f\n", col, out[col]);
}
fclose(fp);
//kernel result
fp = fopen("kernel.txt", "wt");
fprintf(fp, "#\t X\t Y\n");
int left = in.size() - kernel.size() / 2;
int right = left + 1;
for (col = 0; col < left; col++) {
fprintf(fp, "\t %d\t %f\n", col, 0.0);
}
k = col;
for (col = 0; col < kernel.size(); col++) {
fprintf(fp, "\t %d\t %f\n", k++, kernel[i] * 255);
}
for (col = 0; col < right; col++) {
fprintf(fp, "\t %d\t %f\n", k++, 0.0);
}
fclose(fp);
}
#endif
normalization(out, img->width, width);
localMaximaSuppression(out, img->width);
}
else {
out.resize(img->width);
for (col = 0; col < img->width; col++) {
out[col] = 0;
}
}
for (col = 0; col < img->width; col++) {
CvScalar scalar;
scalar.val[0] = out[col];
cvSet2D(img, row, col, scalar);
}
} // end for loop
Contour contour;
contour.findContours(img, camera);
img = contour.drawContours();
cvShowImage("MIT Road Paint Detector", img);
cvWaitKey(0);
cvReleaseImage(&img);
cvDestroyWindow("MIT Read Paint Detector");
return 0;
}
