template<typename real> void
pcl::BivariatePolynomialT<real>::getValueOfGradient (real x, real y, real& gradX, real& gradY)
{
calculateGradient ();
gradX = gradient_x->getValue (x, y);
gradY = gradient_y->getValue (x, y);
}
void
pcl::BivariatePolynomialT<real>::getValueOfGradient (real x, real y, real& gradX, real& gradY)
{
calculateGradient ();
gradX = gradient_x->getValue (x, y);
gradY = gradient_y->getValue (x, y);
//cout << "Gradient at "<<x<<", "<<y<<" is "<<gradX<<", "<<gradY<<"\n";
}
void functionFileNegative(std::string fileName) {
cv::Mat image, angle, scalar;
std::vector<cv::Mat> histograms;
image = cv::imread(fileName);
assert(image.empty() == false);
calculateGradient(image, angle, scalar);
pedestrianPreProcess(image, angle, scalar, histograms, THRESH_TRAIN);
pedestriansDetectionTrainBayes(histograms, sumNegative, sumSqNegative, numberOfNegatives);
}
// ######################################################################
void ContourBoundaryDetector::computeVarianceRidgeBoundaryMap()
{
// get the CIELab variance of the input image
Image<float> varImg = getLabStandardDeviation(itsImage, itsRadius);
// get the gradient of the variance of the image
std::vector<Image<float> > gradImg = calculateGradient(varImg, itsRadius);
// get the ridges in the gradient of the variance image
Image<float> ridgeImg = getRidge(gradImg, itsRadius);
// substract the gradient from the ridge image
itsBoundaryImage = substractGradImg(ridgeImg, gradImg);
}
void Volume::loadVolume(){
cout << "Loading volume..."<<endl;
cout << volSize[0] << " " << volSize[1] << " " << volSize[2] << endl;
mesh -> createParallelepiped(realDimension[0], realDimension[1], realDimension[1]);
cout<< "Parallelepiped created, now to the texture..."<<endl;
scratchTexture = new Texture();
cout << "Texture instantiated." << endl;
scratchTexture->create(GL_TEXTURE_3D, GL_R8, volSize[0], volSize[1], GL_RED, GL_UNSIGNED_BYTE, voxelArray, volSize[2]); // "Id =" because...
//...this funcion returns a GLuint value that represents the texture ID.
cout << "Texture created." << endl;
scratchTexture->setTexParameters(GL_CLAMP, GL_CLAMP, GL_CLAMP, GL_LINEAR, GL_LINEAR);
errorCheckFunc(__FILE__, __LINE__);
cout << "Texture parameters set." << endl;
cout<<"Texture successfully created!"<<endl;
delete voxelArray;
calculateGradient();
errorCheckFunc(__FILE__, __LINE__);
}
int
main(int argc, char **argv)
{
struct part *part;
int opt, n;
int dump_part = 0;
int printStructurePotentialEnergy = 0;
int needVDW = 1;
char *printPotential = NULL;
double printPotentialInitial = -1; // pm
double printPotentialIncrement = -1; // pm
double printPotentialLimit = -1; // pm
char *fileNameTemplate = NULL;
char *outputFilename = NULL;
reinit_globals();
if (signal(SIGTERM, &SIGTERMhandler) == SIG_ERR) {
perror("signal(SIGTERM)");
exit(1);
}
CommandLine = assembleCommandLine(argc, argv);
while ((opt = getopt_long(argc, argv,
"hnmEi:f:s:t:xXONI:K:rD:o:q:B:",
option_vec, NULL)) != -1) {
switch(opt) {
case 'h':
usage();
case OPT_DUMP_PART:
dump_part = 1;
break;
case OPT_WRITE_GROMACS_TOPOLOGY:
GromacsOutputBaseName = optarg;
break;
case OPT_PATH_TO_CPP:
PathToCpp = optarg;
break;
case OPT_SYSTEM_PARAMETERS:
SystemParametersFileName = optarg;
break;
case OPT_PRINT_POTENTIAL:
printPotential = optarg;
break;
case OPT_INITIAL:
printPotentialInitial = atof(optarg);
break;
case OPT_INCREMENT:
printPotentialIncrement = atof(optarg);
break;
case OPT_LIMIT:
printPotentialLimit = atof(optarg);
break;
case OPT_DIRECT_EVALUATE:
DirectEvaluate = 1;
break;
case OPT_INTERPOLATE:
DirectEvaluate = 0;
break;
case OPT_SIMPLE_MOVIE_FORCE_SCALE:
SimpleMovieForceScale = atof(optarg);
break;
case OPT_MIN_THRESH_CUT_RMS:
MinimizeThresholdCutoverRMS = atof(optarg);
break;
case OPT_MIN_THRESH_CUT_MAX:
MinimizeThresholdCutoverMax = atof(optarg);
break;
case OPT_MIN_THRESH_END_RMS:
MinimizeThresholdEndRMS = atof(optarg);
break;
case OPT_MIN_THRESH_END_MAX:
MinimizeThresholdEndMax = atof(optarg);
break;
case OPT_VDW_CUTOFF_RADIUS:
VanDerWaalsCutoffRadius = atof(optarg);
break;
case OPT_VDW_CUTOFF_FACTOR:
VanDerWaalsCutoffFactor = atof(optarg);
break;
case OPT_ENABLE_ELECTROSTATIC:
EnableElectrostatic = atoi(optarg);
break;
case OPT_TIME_REVERSAL:
TimeReversal = 1;
break;
case OPT_THERMOSTAT_GAMMA:
ThermostatGamma = atof(optarg);
break;
case OPT_PRINT_ENERGIES:
PrintPotentialEnergy = 1;
break;
case OPT_NEIGHBOR_SEARCHING:
NeighborSearching = atoi(optarg);
break;
case 'n':
// ignored
break;
case 'm':
ToMinimize=1;
break;
case 'E':
printStructurePotentialEnergy=1;
break;
case 'i':
IterPerFrame = atoi(optarg);
break;
case 'f':
NumFrames = atoi(optarg);
break;
case 's':
Dt = atof(optarg);
break;
case 't':
Temperature = atof(optarg);
break;
case 'x':
DumpAsText = 1;
break;
case 'X':
DumpIntermediateText = 1;
break;
case 'O':
OutputFormat = 1;
break;
case 'N':
OutputFormat = 2;
break;
case OPT_OUTPUT_FORMAT_3:
OutputFormat = 3;
break;
case 'I':
IDKey = optarg;
break;
case 'K':
KeyRecordInterval = atoi(optarg);
break;
case 'r':
PrintFrameNums = 1;
break;
case 'D':
n = atoi(optarg);
if (n < 32 && n >= 0) {
debug_flags |= 1 << n;
}
break;
case 'o':
outputFilename = optarg;
break;
case 'q':
TraceFileName = optarg;
break;
case 'B':
BaseFileName = optarg;
break;
case ':':
case '?':
default:
usage();
exit(1);
}
}
if (optind + 1 == argc) { // (optind < argc) if not paranoid
fileNameTemplate = argv[optind];
}
if (DEBUG(D_PRINT_BEND_STRETCH)) { // -D8
initializeBondTable();
printBendStretch();
exit(0);
}
if (DumpAsText) {
OutputFormat = 0;
}
if (!fileNameTemplate) {
usage();
}
InputFileName = replaceExtension(fileNameTemplate, "mmp");
if (BaseFileName != NULL) {
int i1;
int i2;
struct xyz *basePositions;
struct xyz *initialPositions;
basePositions = readXYZ(BaseFileName, &i1);
if (basePositions == NULL) {
fprintf(stderr, "could not read base positions file from -B<filename>\n");
exit(1);
}
initialPositions = readXYZ(InputFileName, &i2);
if (initialPositions == NULL) {
fprintf(stderr, "could not read comparison positions file\n");
exit(1);
}
if (i1 != i2) {
fprintf(stderr, "structures to compare must have same number of atoms\n");
exit(1);
}
exit(doStructureCompare(i1, basePositions, initialPositions,
NumFrames, 1e-8, 1e-4, 1.0+1e-4));
}
if (outputFilename) {
OutputFileName = copy_string(outputFilename);
} else {
char *extension;
switch (OutputFormat) {
case 0:
extension = "xyz";
break;
case 1:
case 2:
default:
extension = "dpb";
break;
case 3:
extension = "gro";
break;
}
OutputFileName = replaceExtension(fileNameTemplate, extension);
}
if (TraceFileName) {
TraceFile = fopen(TraceFileName, "w");
if (TraceFile == NULL) {
perror(TraceFileName);
exit(1);
}
} else {
TraceFile = fdopen(1, "w");
if (TraceFile == NULL) {
perror("fdopen stdout as TraceFile");
exit(1);
}
}
traceFileVersion(); // call this before any other writes to trace file.
// tell where and how the simulator was built. We never build the
// standalone simulator with distutils.
fprintf(TraceFile, "%s", tracePrefix);
initializeBondTable();
if (IterPerFrame <= 0) IterPerFrame = 1;
if (printPotential) {
printPotentialAndGradientFunctions(printPotential,
printPotentialInitial,
printPotentialIncrement,
printPotentialLimit);
exit(0);
}
part = readMMP(InputFileName);
if (EXCEPTION) {
exit(1);
}
if (GromacsOutputBaseName != NULL) {
needVDW = 0;
}
initializePart(part, needVDW);
createPatterns();
matchPartToAllPatterns(part);
if (printStructurePotentialEnergy) {
struct xyz *force = (struct xyz *)allocate(sizeof(struct xyz) * part->num_atoms);
double potentialEnergy = calculatePotential(part, part->positions);
calculateGradient(part, part->positions, force);
printf("%e %e %e %e (Potential energy in aJ, gradient of atom 1)\n", potentialEnergy, force[1].x, force[1].y, force[1].z);
exit(0);
}
if (dump_part) {
//
// this segment is convenient to run valgrind on to test the
// part and bond table destructors. By the time we reach the
// exit() there should be no malloc'd blocks remaining.
//
// valgrind -v --leak-check=full --leak-resolution=high --show-reachable=yes simulator --dump-part part.mmp
//
printPart(stdout, part);
destroyPart(part);
part = NULL;
destroyBondTable();
fclose(TraceFile);
destroyAccumulator(CommandLine);
free(InputFileName);
free(OutputFileName);
exit(0);
}
if (GromacsOutputBaseName != NULL) {
printGromacsToplogy(GromacsOutputBaseName, part);
destroyPart(part);
part = NULL;
destroyBondTable();
fclose(TraceFile);
destroyAccumulator(CommandLine);
free(InputFileName);
free(OutputFileName);
done("");
exit(0);
}
constrainGlobals();
traceHeader(part);
if (ToMinimize) {
NumFrames = max(NumFrames,(int)sqrt((double)part->num_atoms));
Temperature = 0.0;
} else {
traceJigHeader(part);
}
OutputFile = fopen(OutputFileName, DumpAsText ? "w" : "wb");
if (OutputFile == NULL) {
perror(OutputFileName);
exit(1);
}
writeOutputHeader(OutputFile, part);
if (ToMinimize) {
minimizeStructure(part);
exit(0);
}
else {
dynamicsMovie(part);
}
done("");
return 0;
}
void
oneDynamicsFrame(struct part *part,
int iters,
struct xyz *averagePositions,
struct xyz **pOldPositions,
struct xyz **pNewPositions,
struct xyz **pPositions,
struct xyz *force)
{
int j;
int loop;
double deltaTframe;
struct xyz f;
struct xyz *tmp;
struct jig *jig;
struct xyz *oldPositions = *pOldPositions;
struct xyz *newPositions = *pNewPositions;
struct xyz *positions = *pPositions;
// wware 060109 python exception handling
NULLPTR(part);
NULLPTR(averagePositions);
NULLPTR(oldPositions);
NULLPTR(newPositions);
NULLPTR(positions);
iters = max(iters,1);
deltaTframe = 1.0/iters;
for (j=0; j<part->num_atoms; j++) {
vsetc(averagePositions[j],0.0);
}
// See http://www.nanoengineer-1.net/mediawiki/index.php?title=Verlet_integration
// for a discussion of how dynamics is done in the simulator.
// we want:
// x(t+dt) = 2x(t) - x(t-dt) + A dt^2
// or:
// newPositions = 2 * positions - oldPositions + A dt^2
// wware 060110 don't handle Interrupted with the BAIL mechanism
for (loop=0; loop < iters && !Interrupted; loop++) {
_last_iteration = loop == iters - 1;
Iteration++;
// wware 060109 python exception handling
updateVanDerWaals(part, NULL, positions); BAIL();
calculateGradient(part, positions, force); BAIL();
/* first, for each atom, find non-accelerated new pos */
/* Atom moved from oldPositions to positions last time,
now we move it the same amount from positions to newPositions */
for (j=0; j<part->num_atoms; j++) {
// f = positions - oldPositions
vsub2(f,positions[j],oldPositions[j]);
// newPositions = positions + f
// or:
// newPositions = 2 * positions - oldPositions
vadd2(newPositions[j],positions[j],f);
// after this, we will need to add A dt^2 to newPositions
}
// pre-force jigs
for (j=0;j<part->num_jigs;j++) { /* for each jig */
jig = part->jigs[j];
// wware 060109 python exception handling
NULLPTR(jig);
switch (jig->type) {
case LinearMotor:
jigLinearMotor(jig, positions, newPositions, force, deltaTframe);
break;
default:
break;
}
}
/* convert forces to accelerations, giving new positions */
//FoundKE = 0.0; /* and add up total KE */
for (j=0; j<part->num_atoms; j++) {
// to complete Verlet integration, this needs to do:
// newPositions += A dt^2
//
// force[] is in pN, mass is in g, Dt in seconds, f in pm
vmul2c(f,force[j],part->atoms[j]->inverseMass); // inverseMass = Dt*Dt/mass
// XXX: 0.15 probably needs a scaling by Dt
// 0.15 = deltaX
// keMax = m v^2 / 2
// v^2 = 2 keMax / m
// v = deltaX / Dt = sqrt(2 keMax / m)
// deltaX = Dt sqrt(2 keMax / m)
// We probably don't want to do this, because a large raw
// velocity isn't a problem, it's just when that creates a
// high force between atoms that it becomes a problem. We
// check that elsewhere.
//if (!ExcessiveEnergyWarning && vlen(f)>0.15) { // 0.15 is just below H flyaway
// WARNING3("Excessive force %.6f in iteration %d on atom %d -- further warnings suppressed", vlen(f), Iteration, j+1);
// ExcessiveEnergyWarningThisFrame++;
//}
vadd(newPositions[j],f);
//vsub2(f, newPositions[j], positions[j]);
//ff = vdot(f, f);
//FoundKE += atom[j].energ * ff;
}
// Jigs are executed in the following order: motors,
// thermostats, grounds, measurements. Motions from each
// motor are added together, then thermostats operate on the
// motor output. Grounds override anything that moves atoms.
// Measurements happen after all things that could affect
// positions, including grounds.
// motors
for (j=0;j<part->num_jigs;j++) { /* for each jig */
jig = part->jigs[j];
if (jig->type == RotaryMotor) {
jigMotor(jig, deltaTframe, positions, newPositions, force);
}
// LinearMotor handled in preforce above
}
// thermostats
for (j=0;j<part->num_jigs;j++) { /* for each jig */
jig = part->jigs[j];
if (jig->type == Thermostat) {
jigThermostat(jig, deltaTframe, positions, newPositions);
}
}
// grounds
for (j=0;j<part->num_jigs;j++) { /* for each jig */
jig = part->jigs[j];
if (jig->type == Ground) {
jigGround(jig, deltaTframe, positions, newPositions, force);
}
}
// measurements
for (j=0;j<part->num_jigs;j++) { /* for each jig */
jig = part->jigs[j];
switch (jig->type) {
case Thermometer:
jigThermometer(jig, deltaTframe, positions, newPositions);
break;
case DihedralMeter:
jigDihedral(jig, newPositions);
break;
case AngleMeter:
jigAngle(jig, newPositions);
break;
case RadiusMeter:
jigRadius(jig, newPositions);
break;
default:
break;
}
}
for (j=0; j<part->num_atoms; j++) {
vadd(averagePositions[j],newPositions[j]);
}
tmp=oldPositions; oldPositions=positions; positions=newPositions; newPositions=tmp;
if (ExcessiveEnergyWarningThisFrame > 0) {
ExcessiveEnergyWarning = 1;
}
}
for (j=0; j<part->num_atoms; j++) {
vmulc(averagePositions[j],deltaTframe);
}
*pOldPositions = oldPositions;
*pNewPositions = newPositions;
*pPositions = positions;
}
static inline void detectPedestrian(std::string imageFileName) {
cv::Mat originalImage, finalImage;
std::vector<mpf_class> meanPositive, standPositive, meanNegative, standNegative;
std::vector<cv::Rect> rects, validRects;
int i, scale, a, b;
unsigned int numberOfPositives, numberOfNegatives;
originalImage = cv::imread(imageFileName);
assert(originalImage.empty() == false);
loadValuesBayes(meanPositive, standPositive, meanNegative, standNegative,
numberOfPositives, numberOfNegatives);
//image = originalImage.clone();
for (scale = 1; scale <= 2; scale *= 2) {
std::vector<cv::Point> realPedestrians;
cv::Mat image, angle, scalar;
std::vector<cv::Point> pedestrians;
std::vector<cv::Mat> histograms;
std::vector<mpf_class**> histogramsIntegral;
#if DEBUG
std::cout << "scale = " << scale << std::endl;
#endif
cv::resize(originalImage,
image,
cv::Size(
originalImage.size().width * scale,
originalImage.size().height * scale));
calculateGradient(image, angle, scalar);
pedestrianPreProcess(image, angle, scalar, histograms, THRESH_CLASS);
pedestriansInitialDetection(histograms, pedestrians, histogramsIntegral);
pedestriansDetectionBayes(histograms, pedestrians,
meanPositive, standPositive, meanNegative, standNegative,
realPedestrians, numberOfPositives, numberOfNegatives);
for (i = 0; i < realPedestrians.size(); i++) {
//std::cout << realPedestrians[i] << std::endl;
cv::Rect rect;
rect.x = round(realPedestrians[i].x / ((double) scale));
rect.y = round(realPedestrians[i].y / ((double) scale));
rect.width = round(PERSON_WINDOW_W / ((double) scale));
rect.height = round(PERSON_WINDOW_H / ((double) scale));
/*cv::rectangle(initialImage,
cv::Rect(realPedestrians[i].x,
realPedestrians[i].y,
PERSON_WINDOW_W,
PERSON_WINDOW_H),
cv::Scalar(0, 0, 255));*/
rects.push_back(rect);
#if DEBUG
std::cout << rect << std::endl;
#endif
}
}
postProcess(rects, validRects);
rects = std::vector<cv::Rect>(validRects);
validRects.clear();
finalImage = originalImage.clone();
for (i = 0; i < rects.size(); i++) {
cv::rectangle(finalImage,
rects[i],
cv::Scalar(0, 0, 255));
}
imageFileName = std::string("saida/") +
std::string(
basename(imageFileName.replace(imageFileName.find("qx"), 2, "qp").c_str()));
cv::imwrite(imageFileName, finalImage);
originalImage.release();
finalImage.release();
}
void CVPolicyLearner::nextStep(CStateCollection *, CAction *action, double , CStateCollection *nextState)
{
int nForwardView = (int) getParameter("PolicyLearningFowardView");
int nBackwardView = (int) getParameter("PolicyLearningBackwardView");
CStateCollectionImpl *currentState;
CContinuousActionData *currentAction;
if (statesResource->size() > 0)
{
currentAction = *actionsResource->begin();
actionsResource->pop_front();
currentState = *statesResource->begin();
statesResource->pop_front();
}
else
{
currentAction = new CContinuousActionData(gradientPolicy->getContinuousAction()->getContinuousActionProperties());
currentState = new CStateCollectionImpl(dynModel->getStateProperties(), stateModifiers);
}
currentAction->setData(action->getActionData());
currentState->setStateCollection(nextState);
pastStates->push_back(currentState);
pastActions->push_back(currentAction);
// FORWARD View
int gradientPolicyRandomMode = gradientPolicy->getRandomControllerMode();
gradientPolicy->setRandomControllerMode(NO_RANDOM_CONTROLLER);
ColumnVector *currentReward;
for (int i = 0; i < nForwardView - 1; i ++)
{
CStateCollection *lastState = *pastStates->rbegin();
if (statesResource->size() > 0)
{
currentAction = *actionsResource->begin();
actionsResource->pop_front();
currentState = *statesResource->begin();
statesResource->pop_front();
}
else
{
currentAction = new CContinuousActionData(gradientPolicy->getContinuousAction()->getContinuousActionProperties());
currentState = new CStateCollectionImpl(dynModel->getStateProperties(), stateModifiers);
}
if (rewardsResource->size() > 0)
{
currentReward = *rewardsResource->begin();
rewardsResource->pop_front();
}
else
{
currentReward = new ColumnVector(dynModel->getNumContinuousStates());
}
gradientPolicy->getNextContinuousAction(lastState, currentAction);
dynModel->transitionFunction(lastState->getState(dynModel->getStateProperties()), gradientPolicy->getContinuousAction(), currentState->getState(dynModel->getStateProperties()),currentAction);
currentState->newModelState();
rewardFunction->getInputDerivation(lastState->getState(dynModel->getStateProperties()), currentReward);
pastStates->push_back(currentState);
pastDRewards->push_back(currentReward);
pastActions->push_back(currentAction);
}
calculateGradient(pastStates, pastDRewards, pastActions, policyGradient);
DebugPrint('p', "policyGradient for Update : ");
if (DebugIsEnabled('p'))
{
policyGradient->saveASCII(DebugGetFileHandle('p'));
}
gradientPolicy->updateGradient(policyGradient, getParameter("PolicyLearningRate"));
gradientPolicy->setRandomControllerMode(gradientPolicyRandomMode);
for (int i = 0; i < nForwardView - 1; i ++)
{
statesResource->push_back(*pastStates->rbegin());
actionsResource->push_back(*pastActions->rbegin());
pastStates->pop_back();
pastActions->pop_back();
rewardsResource->push_back(*pastDRewards->rbegin());
pastDRewards->pop_back();
}
if (nBackwardView > 0)
{
if (rewardsResource->size() > 0)
{
currentReward = *rewardsResource->begin();
rewardsResource->pop_front();
}
else
{
currentReward = new ColumnVector(dynModel->getNumContinuousStates());
}
rewardFunction->getInputDerivation((*pastStates->rbegin())->getState(dynModel->getStateProperties()), currentReward);
pastDRewards->push_back(currentReward);
}
if (pastStates->size() > (unsigned int) nBackwardView)
{
statesResource->push_back(*pastStates->begin());
actionsResource->push_back(*pastActions->begin());
pastStates->pop_front();
pastActions->pop_front();
if (nBackwardView > 0)
{
rewardsResource->push_back(*pastDRewards->begin());
pastDRewards->pop_front();
}
}
}