bool Player::setVolumeGroup(double volume) { if (m_player) { bool ret = true; if (roundDouble(volume) == m_RCGroup.volume) return true; double r = (volume > 0 ? volume : 1.0); if (m_RCGroup.volumeFake > 0.0) r /= m_RCGroup.volumeFake; for (RCTable::iterator it = m_RCTable.begin(); it != m_RCTable.end(); ++it) { double fake = it->volumeFake * r; int v = roundDouble(fake < 1.0 ? 0.0 : fake < 100.0 ? fake : 100.0); SONOS::DBG(DBG_DEBUG, "%s: req=%3.3f ratio=%3.3f fake=%3.3f vol=%d\n", __FUNCTION__, volume, r, fake, v); if (m_player->SetVolume(it->uuid, v)) it->volumeFake = fake; else ret = false; } if (ret) m_RCGroup.volume = roundDouble(m_RCGroup.volumeFake = volume); emit renderingChanged(); return ret; } return false; }
int writeMax(EmbPattern* pattern, const char* fileName) { EmbStitchList* pointer; char header[] = {0x56,0x43,0x53,0x4D,0xFC,0x03,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00, 0xF6,0x25,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x05,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x31,0x33,0x37,0x38, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x4D,0x61,0x64,0x65,0x69,0x72,0x61,0x20, 0x52,0x61,0x79,0x6F,0x6E,0x20,0x34,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x01,0x38,0x09,0x31,0x33,0x30,0x2F,0x37,0x30,0x35,0x20,0x48,0xFA,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00}; FILE *file = fopen(fileName, "wb"); if(file == 0) { return 0; } binaryWriteBytes(file, header, 0xD5); pointer = pattern->stitchList; while(pointer) { maxEncode(file, roundDouble(pointer->stitch.xx * 10.0), roundDouble(pointer->stitch.yy * 10.0)); pointer = pointer->next; } fclose(file); return 1; }
/*! Writes the data from \a pattern to a file with the given \a fileName. * Returns \c true if successful, otherwise returns \c false. */ int writeExp(EmbPattern* pattern, const char* fileName) { #ifdef ARDUINO /* ARDUINO TODO: This is temporary. Remove when complete. */ return 0; /* ARDUINO TODO: This is temporary. Remove when complete. */ #else /* ARDUINO TODO: This is temporary. Remove when complete. */ EmbFile* file = 0; EmbStitchList* stitches = 0; double dx = 0.0, dy = 0.0; double xx = 0.0, yy = 0.0; int flags = 0; unsigned char b[4]; if(!pattern) { embLog_error("format-exp.c writeExp(), pattern argument is null\n"); return 0; } if(!fileName) { embLog_error("format-exp.c writeExp(), fileName argument is null\n"); return 0; } if(!embStitchList_count(pattern->stitchList)) { embLog_error("format-exp.c writeExp(), pattern contains no stitches\n"); return 0; } /* Check for an END stitch and add one if it is not present */ if(pattern->lastStitch->stitch.flags != END) embPattern_addStitchRel(pattern, 0, 0, END, 1); file = embFile_open(fileName, "wb"); if(!file) { embLog_error("format-exp.c writeExp(), cannot open %s for writing\n", fileName); return 0; } /* write stitches */ stitches = pattern->stitchList; while(stitches) { dx = stitches->stitch.xx * 10.0 - xx; dy = stitches->stitch.yy * 10.0 - yy; xx = stitches->stitch.xx * 10.0; yy = stitches->stitch.yy * 10.0; flags = stitches->stitch.flags; expEncode(b, (char)roundDouble(dx), (char)roundDouble(dy), flags); if((b[0] == 128) && ((b[1] == 1) || (b[1] == 2) || (b[1] == 4))) { embFile_printf(file, "%c%c%c%c", b[0], b[1], b[2], b[3]); } else { embFile_printf(file, "%c%c", b[0], b[1]); } stitches = stitches->next; } embFile_printf(file, "\x1a"); embFile_close(file); return 1; #endif /* ARDUINO TODO: This is temporary. Remove when complete. */ }
/*! Writes the data from \a pattern to a file with the given \a fileName. * Returns \c true if successful, otherwise returns \c false. */ int writeT01(EmbPattern* pattern, const char* fileName) { EmbRect boundingRect; EmbFile* file = 0; int xx, yy, dx, dy, flags; int co = 1, st = 0; int ax, ay, mx, my; EmbStitchList* pointer = 0; if (!embStitchList_count(pattern->stitchList)) { embLog_error("format-t01.c writeDst(), pattern contains no stitches\n"); return 0; } /* Check for an END stitch and add one if it is not present */ if (pattern->lastStitch->stitch.flags != END) embPattern_addStitchRel(pattern, 0, 0, END, 1); file = embFile_open(fileName, "wb"); if (!file) { embLog_error("format-t01.c writet01(), cannot open %s for writing\n", fileName); return 0; } embPattern_correctForMaxStitchLength(pattern, 12.1, 12.1); xx = yy = 0; co = 1; co = embThreadList_count(pattern->threadList); st = 0; st = embStitchList_count(pattern->stitchList); flags = NORMAL; boundingRect = embPattern_calcBoundingBox(pattern); ax = ay = mx = my = 0; xx = yy = 0; pointer = pattern->stitchList; while (pointer) { /* convert from mm to 0.1mm for file format */ dx = roundDouble(pointer->stitch.xx * 10.0) - xx; dy = roundDouble(pointer->stitch.yy * 10.0) - yy; xx = roundDouble(pointer->stitch.xx * 10.0); yy = roundDouble(pointer->stitch.yy * 10.0); flags = pointer->stitch.flags; encode_record(file, dx, dy, flags); pointer = pointer->next; } embFile_close(file); return 1; }
static void pecEncode(EmbFile* file, EmbPattern* p) { double thisX = 0.0; double thisY = 0.0; unsigned char stopCode = 2; EmbStitchList* list = 0; if(!file) { embLog_error("format-pec.c pecEncode(), file argument is null\n"); return; } if(!p) { embLog_error("format-pec.c pecEncode(), p argument is null\n"); return; } list = p->stitchList; while(list) { int deltaX, deltaY; EmbStitch s = list->stitch; deltaX = roundDouble(s.xx - thisX); deltaY = roundDouble(s.yy - thisY); thisX += (double)deltaX; thisY += (double)deltaY; if(s.flags & STOP) { pecEncodeStop(file, stopCode); if(stopCode == (unsigned char)2) { stopCode = (unsigned char)1; } else { stopCode = (unsigned char)2; } } else if(s.flags & END) { binaryWriteByte(file, 0xFF); break; } else if(deltaX < 63 && deltaX > -64 && deltaY < 63 && deltaY > -64 && (!(s.flags & (JUMP | TRIM)))) { binaryWriteByte(file, (deltaX < 0) ? (unsigned char)(deltaX + 0x80) : (unsigned char)deltaX); binaryWriteByte(file, (deltaY < 0) ? (unsigned char)(deltaY + 0x80) : (unsigned char)deltaY); } else { pecEncodeJump(file, deltaX, s.flags); pecEncodeJump(file, deltaY, s.flags); } list = list->next; } }
static void xxxEncodeStitch(FILE* file, double deltaX, double deltaY, int flags) { if((flags & (JUMP | TRIM)) && (fabs(deltaX) > 124 || fabs(deltaY) > 124)) { binaryWriteByte(file, 0x7E); binaryWriteShort(file, (short)deltaX); binaryWriteShort(file, (short)deltaY); } else { /* TODO: Verify this works after changing this to unsigned char */ binaryWriteByte(file, (unsigned char)roundDouble(deltaX)); binaryWriteByte(file, (unsigned char)roundDouble(deltaY)); } }
/********************************************************* *NAME: utilCalcTankSlide *AUTHOR: Chris Lesnieski *CREATION DATE: 2009-01-04 *LAST MODIFIED: 2009-01-04 *PURPOSE: * Calculates the X and Y distance a tank should move * after being hit by a shell. We do not decrement the * tank slide timer here as that is handled by code in the * tankUpdate() method. * *ARGUMENTS: * tankSlideTimer - The number of ticks left to slide * angle - The angle at which the shell was travelling * xAmount - The amount to add in the X direction * yAmount - The amount to add in the Y direction * speed - The speed of the tank *********************************************************/ void utilCalcTankSlide(BYTE tankSlideTimer, TURNTYPE angle, int *xAmount, int *yAmount, int speed) { float angleRad; float ratio; angleRad = mathConvertBradianToRadian(angle); /* This ratio is not right as it is but it sure is fun to play with */ ratio = (float)tankSlideTimer / (float)speed; /* Calculate the change in both x and y directions */ *xAmount = (int) roundDouble((ratio * cos(angleRad))); *yAmount = (int) roundDouble((ratio * sin(angleRad)) * -1); return; }
int loadImageSDRAM(void* sdram_ptr, int num) { char filename[40]; snprintf(filename, sizeof(filename), "Test Data/image%d.csv", num); FILE* imgData = fopen(filename, "r"); if(imgData == NULL) { printf("file open fail, check if \"Test Data/image%d.csv\" is a valid file\n", num); return -1; } int i, j; double value; char temp; unsigned short toStore; for(i = 0; i < 49; i++) { toStore = 0; for(j = 0; j < 16; j++) { fscanf(imgData, "%lf", &value); fscanf(imgData, "%c", &temp); toStore = toStore + (unsigned short)(roundDouble(value) << j); } ((unsigned short*) sdram_ptr)[i] = toStore; //printf("%d\n", toStore); } fclose(imgData); return 0; }
/********************************************************* *NAME: utilCalcDistance *AUTHOR: John Morrison *CREATION DATE: 25/12/98 *LAST MODIFIED: 25/12/98 *PURPOSE: * Calculates the X and Y distance an object * should move from a given speed and angle * *ARGUMENTS: * xAmount - The amount to add in the X direction * yAmount - The amount to add in the Y direction * angle - The angle the tank is facing * speed - The speed of the tank *********************************************************/ void utilCalcDistance(int *xAmount, int *yAmount, TURNTYPE angle, int speed) { double dbAngle; /* Floating piont number for calculations */ /* Take away 64 bradians to make angle correct for sin/cos calculations */ angle -= BRADIANS_EAST; if (angle < 0) { angle += BRADIANS_MAX; } /* Convert bradians to degrees */ dbAngle = (DEGREES_MAX / BRADIANS_MAX) * angle; /* Convert degrees to radians */ dbAngle = (dbAngle / DEGREES_MAX) * RADIANS_MAX; /* Perform calculation */ *xAmount = (int) roundDouble((speed * cos(dbAngle))); *yAmount = (int) roundDouble((speed * sin(dbAngle))); }
int writeExp(EmbPattern* pattern, const char* fileName) { FILE* file; EmbStitchList *stitches; double dx = 0.0, dy = 0.0; double xx = 0.0, yy = 0.0; int flags = 0; int i = 0; unsigned char b[4]; file = fopen(fileName, "wb"); if(file == 0) { /*TODO: set status here "Error opening EXP file for write:" */ return 0; } /* write stitches */ stitches = pattern->stitchList; while(stitches) { dx = stitches->stitch.xx * 10.0 - xx; dy = stitches->stitch.yy * 10.0 - yy; xx = stitches->stitch.xx * 10.0; yy = stitches->stitch.yy * 10.0; flags = stitches->stitch.flags; expEncode(b, roundDouble(dx), roundDouble(dy), flags); if((b[0] == 128) && ((b[1] == 1) || (b[1] == 2) || (b[1] == 4))) { fprintf(file, "%c%c%c%c", b[0], b[1], b[2], b[3]); } else { fprintf(file, "%c%c", b[0], b[1]); } stitches = stitches->next; } fprintf(file, "\x1a"); fclose(file); return 1; }
/** * The synthetic video sequence we will work with here is composed of a * single moving object, circular in shape (fixed radius) * The motion here is a linear motion * the foreground intensity and the backgrounf intensity is known * the image is corrupted with zero mean Gaussian noise * @param I The video itself * @param IszX The x dimension of the video * @param IszY The y dimension of the video * @param Nfr The number of frames of the video * @param seed The seed array used for number generation */ void videoSequence(int * I, int IszX, int IszY, int Nfr, int * seed){ int k; int max_size = IszX*IszY*Nfr; /*get object centers*/ int x0 = (int)roundDouble(IszY/2.0); int y0 = (int)roundDouble(IszX/2.0); I[x0 *IszY *Nfr + y0 * Nfr + 0] = 1; /*move point*/ int xk, yk, pos; for(k = 1; k < Nfr; k++){ xk = abs(x0 + (k-1)); yk = abs(y0 - 2*(k-1)); pos = yk * IszY * Nfr + xk *Nfr + k; if(pos >= max_size) pos = 0; I[pos] = 1; } /*dilate matrix*/ int * newMatrix = (int *)malloc(sizeof(int)*IszX*IszY*Nfr); memset(newMatrix, 0, sizeof(int) * max_size); imdilate_disk(I, IszX, IszY, Nfr, 5, newMatrix); int x, y; for(x = 0; x < IszX; x++){ for(y = 0; y < IszY; y++){ for(k = 0; k < Nfr; k++){ I[x*IszY*Nfr + y*Nfr + k] = newMatrix[x*IszY*Nfr + y*Nfr + k]; } } } free(newMatrix); /*define background, add noise*/ setIf(0, 100, I, &IszX, &IszY, &Nfr); setIf(1, 228, I, &IszX, &IszY, &Nfr); /*add noise*/ addNoise(I, &IszX, &IszY, &Nfr, seed); }
bool Player::setVolume(const QString& uuid, double volume) { if (m_player) { double fake = 0.0; std::string _uuid = uuid.toUtf8().constData(); for (RCTable::iterator it = m_RCTable.begin(); it != m_RCTable.end(); ++it) { if (it->uuid == _uuid) { int v = roundDouble(volume); if (!m_player->SetVolume(it->uuid, v)) return false; it->volumeFake = (v == 0 ? 100.0 / 101.0 : volume); it->volume = v; } fake += it->volumeFake; } fake /= m_RCTable.size(); m_RCGroup.volume = roundDouble(m_RCGroup.volumeFake = fake); emit renderingGroupChanged(); } return false; }
void loadWeightCSV(FILE* file, void* sdram_ptr, int sdram_offset, int rows, int cols) { int i, j, k, l; double value; char temp; unsigned short toStore = 0; k = 0; l = 0; for(i = 0; i < rows; i++) { for(j = 0; j < cols; j++) { fscanf(file, "%lf", &value); fscanf(file, "%c", &temp); unsigned short num = 0; if(sdram_offset == W3_OFST) { value = value * 10; } int round = roundDouble(value); if(round < 0) { num = (round <= -8) ? 8 : convertBinPos(round); } else { num = (round > 7) ? 7 : round; } toStore = toStore + (num << (4 * k)); if(k == 3 || (j == (cols - 1))) { ((unsigned short*) sdram_ptr)[sdram_offset + l] = toStore; k = 0; toStore = 0; l++; } else { k++; } } } }
void loadBiasCSV(FILE* file, void* sdram_ptr, int sdram_offset, int rows) { int i, j, k; double value; char temp; unsigned short toStore = 0; unsigned short num = 0; j = 0; k = 0; for(i = 0; i < rows; i++) { fscanf(file, "%lf", &value); fscanf(file, "%c", &temp); int round = roundDouble(value); if(round < 0) { num = (round <= -8) ? 8 : convertBinPos(round); } else { num = (round >= 7.5) ? 7 : round; } toStore = toStore + (num << (j * 4)); if(j == 3) { if(k == (rows / 4)) { printf("*** LOAD BIAS GOING OUT OF BOUNDS ***\n"); } ((unsigned short*) sdram_ptr)[sdram_offset + k] = toStore; j = 0; toStore = 0; k++; } else { j++; } } }
int writeHus(EmbPattern* pattern, const char* fileName) { EmbRect boundingRect; int stitchCount, minColors, patternColor; int attributeSize = 0; int xCompressedSize = 0; int yCompressedSize = 0; double previousX = 0; double previousY = 0; unsigned char* xValues, *yValues, *attributeValues; EmbStitchList* pointer = 0; double xx = 0.0; double yy = 0.0; int flags = 0; int i = 0; unsigned char* attributeCompressed, *xCompressed, *yCompressed; FILE* file = 0; file = fopen(fileName, "wb"); if(!file) { /*TODO: set status here "Error opening HUS file for write:" */ return 0; } stitchCount = embStitchList_count(pattern->stitchList); /* embPattern_correctForMaxStitchLength(pattern, 0x7F, 0x7F); */ minColors = embThreadList_count(pattern->threadList); patternColor = minColors; if(minColors > 24) minColors = 24; binaryWriteUInt(file, 0x00C8AF5B); binaryWriteUInt(file, stitchCount); binaryWriteUInt(file, minColors); boundingRect = embPattern_calcBoundingBox(pattern); binaryWriteShort(file, (short) roundDouble(boundingRect.right * 10.0)); binaryWriteShort(file, (short) -roundDouble(boundingRect.top * 10.0 - 1.0)); binaryWriteShort(file, (short) roundDouble(boundingRect.left * 10.0)); binaryWriteShort(file, (short) -roundDouble(boundingRect.bottom * 10.0 - 1.0)); binaryWriteUInt(file, 0x2A + 2 * minColors); xValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount)); /* TODO: malloc fail error */ yValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount)); /* TODO: malloc fail error */ attributeValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount)); /* TODO: malloc fail error */ pointer = pattern->stitchList; while(pointer) { xx = pointer->stitch.xx; yy = pointer->stitch.yy; flags = pointer->stitch.flags; xValues[i] = husEncodeByte((xx - previousX) * 10.0); previousX = xx; yValues[i] = husEncodeByte((yy - previousY) * 10.0); previousY = yy; attributeValues[i] = husEncodeStitchType(flags); pointer = pointer->next; i++; } attributeCompressed = husCompressData(attributeValues, stitchCount, &attributeSize); xCompressed = husCompressData(xValues, stitchCount, &xCompressedSize); yCompressed = husCompressData(yValues, stitchCount, &yCompressedSize); /* TODO: error if husCompressData returns zero? */ binaryWriteUInt(file, (unsigned int) (0x2A + 2 * patternColor + attributeSize)); binaryWriteUInt(file, (unsigned int) (0x2A + 2 * patternColor + attributeSize + xCompressedSize)); binaryWriteUInt(file, 0x00000000); binaryWriteUInt(file, 0x00000000); binaryWriteUShort(file, 0x0000); for(i = 0; i < patternColor; i++) { binaryWriteShort(file, (short)embThread_findNearestColorInArray(embThreadList_getAt(pattern->threadList, i).color, (EmbThread*)husThreads, husThreadCount)); } binaryWriteBytes(file, (char*) attributeCompressed, attributeSize); binaryWriteBytes(file, (char*) xCompressed, xCompressedSize); binaryWriteBytes(file, (char*) yCompressed, yCompressedSize); free(xValues); free(xCompressed); free(yValues); free(yCompressed); free(attributeValues); free(attributeCompressed); fclose(file); return 1; }
void Player::handleRenderingControlChange() { if (m_player) { #define RENDERING_UNCHANGED 0 #define RENDERING_GROUP_CHANGED 1 #define RENDERING_CHANGED 2 unsigned signalMask = RENDERING_UNCHANGED; SONOS::SRPList props = m_player->GetRenderingProperty(); // Setup fake volumes if (m_RCTable.empty()) { double volume = 0.0; bool mute = true; SONOS::SRPList::const_iterator it = props.begin(); while (it != props.end()) { RCProperty item; item.uuid = it->uuid; item.name = it->subordinateName; item.mute = it->property.MuteMaster ? true : false; item.volume = it->property.VolumeMaster; item.volumeFake = it->property.VolumeMaster > 0 ? (double)it->property.VolumeMaster : 100.0 / 101.0; m_RCTable.push_back(item); if (!item.mute) mute = false; // exists active audio in group volume += item.volumeFake; ++it; } volume /= (double)props.size(); m_RCGroup.volumeFake = volume; m_RCGroup.volume = roundDouble(volume); m_RCGroup.mute = mute; signalMask |= RENDERING_GROUP_CHANGED | RENDERING_CHANGED; // handles group & subordinate update } else { double volume = 0.0; bool mute = true; SONOS::SRPList::const_iterator it = props.begin(); std::vector<RCProperty>::iterator itz = m_RCTable.begin(); while (it != props.end()) { bool _mute = it->property.MuteMaster ? true : false; if (_mute != itz->mute) { itz->mute = _mute; signalMask |= RENDERING_CHANGED; } if (it->property.VolumeMaster != itz->volume) { itz->volume = it->property.VolumeMaster; if (it->property.VolumeMaster > 0 && it->property.VolumeMaster < 100 && it->property.VolumeMaster != roundDouble(itz->volumeFake)) { itz->volumeFake = (double)it->property.VolumeMaster; signalMask |= RENDERING_CHANGED; } else if (it->property.VolumeMaster == 100 && itz->volumeFake < 100.0) { itz->volumeFake = (double)it->property.VolumeMaster; signalMask |= RENDERING_CHANGED; } else if (it->property.VolumeMaster == 0 && itz->volumeFake >= 1.0) { itz->volumeFake = 100.0 / 101.0; signalMask |= RENDERING_CHANGED; } } SONOS::DBG(DBG_DEBUG, "%s: [%s] sig=%d volume: %3.3f [%d]\n", __FUNCTION__, it->uuid.c_str(), signalMask, itz->volumeFake, itz->volume); if (!itz->mute) mute = false; // exists active audio in group volume += itz->volumeFake; ++it; ++itz; } volume /= (double)props.size(); m_RCGroup.volumeFake = volume; m_RCGroup.volume = roundDouble(volume); m_RCGroup.mute = mute; signalMask |= RENDERING_GROUP_CHANGED; // handles group update } SONOS::DBG(DBG_DEBUG, "%s: sig=%d volume: %3.3f [%d]\n", __FUNCTION__, signalMask, m_RCGroup.volumeFake, m_RCGroup.volume); // emit signal about changes if (signalMask & RENDERING_GROUP_CHANGED) emit renderingGroupChanged(); if (signalMask & RENDERING_CHANGED) emit renderingChanged(); } }
/** * The implementation of the particle filter using OpenMP for many frames * @see http://openmp.org/wp/ * @note This function is designed to work with a video of several frames. In addition, it references a provided MATLAB function which takes the video, the objxy matrix and the x and y arrays as arguments and returns the likelihoods * @param I The video to be run * @param IszX The x dimension of the video * @param IszY The y dimension of the video * @param Nfr The number of frames * @param seed The seed array used for random number generation * @param Nparticles The number of particles to be used */ int particleFilter(unsigned char * I, int IszX, int IszY, int Nfr, int * seed, int Nparticles) { int max_size = IszX * IszY*Nfr; //original particle centroid double xe = roundDouble(IszY / 2.0); double ye = roundDouble(IszX / 2.0); //expected object locations, compared to center int radius = 5; int diameter = radius * 2 - 1; int * disk = (int*) calloc(diameter * diameter, sizeof (int)); strelDisk(disk, radius); int countOnes = 0; int x, y; for (x = 0; x < diameter; x++) { for (y = 0; y < diameter; y++) { if (disk[x * diameter + y] == 1) countOnes++; } } int * objxy = (int *) calloc(countOnes * 2, sizeof(int)); getneighbors(disk, countOnes, objxy, radius); //initial weights are all equal (1/Nparticles) double * weights = (double *) calloc(Nparticles, sizeof(double)); for (x = 0; x < Nparticles; x++) { weights[x] = 1 / ((double) (Nparticles)); } /**************************************************************** ************** B E G I N A L L O C A T E ******************* ****************************************************************/ /***** kernel variables ******/ cl_kernel kernel_likelihood; cl_kernel kernel_sum; cl_kernel kernel_normalize_weights; cl_kernel kernel_find_index; int sourcesize = 2048 * 2048; char * source = (char *) calloc(sourcesize, sizeof (char)); if (!source) { printf("ERROR: calloc(%d) failed\n", sourcesize); return -1; } // read the kernel core source char * tempchar = "./particle_double.cl"; FILE * fp = fopen(tempchar, "rb"); if (!fp) { printf("ERROR: unable to open '%s'\n", tempchar); return -1; } fread(source + strlen(source), sourcesize, 1, fp); fclose(fp); // OpenCL initialization int use_gpu = 1; if (initialize(use_gpu)) return -1; // compile kernel cl_int err = 0; const char * slist[2] = {source, 0}; cl_program prog = clCreateProgramWithSource(context, 1, slist, NULL, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateProgramWithSource() => %d\n", err); return -1; } err = clBuildProgram(prog, 1, device_list, "-cl-fast-relaxed-math", NULL, NULL); if (err != CL_SUCCESS) { if (err == CL_INVALID_PROGRAM) printf("CL_INVALID_PROGRAM\n"); else if (err == CL_INVALID_VALUE) printf("CL_INVALID_VALUE\n"); else if (err == CL_INVALID_DEVICE) printf("CL_INVALID_DEVICE\n"); else if (err == CL_INVALID_BINARY) printf("CL_INVALID_BINARY\n"); else if (err == CL_INVALID_BUILD_OPTIONS) printf("CL_INVALID_BUILD_OPTIONS\n"); else if (err == CL_INVALID_OPERATION) printf("CL_INVALID_OPERATION\n"); else if (err == CL_COMPILER_NOT_AVAILABLE) printf("CL_COMPILER_NOT_AVAILABLE\n"); else if (err == CL_BUILD_PROGRAM_FAILURE) printf("CL_BUILD_PROGRAM_FAILURE\n"); else if (err == CL_INVALID_OPERATION) printf("CL_INVALID_OPERATION\n"); else if (err == CL_OUT_OF_RESOURCES) printf("CL_OUT_OF_RESOURCES\n"); else if (err == CL_OUT_OF_HOST_MEMORY) printf("CL_OUT_OF_HOST_MEMORY\n"); printf("ERROR: clBuildProgram() => %d\n", err); static char log[65536]; memset(log, 0, sizeof (log)); err = clGetProgramBuildInfo(prog, device_list[0], CL_PROGRAM_BUILD_LOG, sizeof (log) - 1, log, NULL); if (err != CL_SUCCESS) { printf("ERROR: clGetProgramBuildInfo() => %d\n", err); } if (strstr(log, "warning:") || strstr(log, "error:")) printf("<<<<\n%s\n>>>>\n", log); } // { // show warnings/errors // static char log[65536]; // memset(log, 0, sizeof (log)); // cl_device_id device_id[2] = {0}; // err = clGetContextInfo(context, CL_CONTEXT_DEVICES, sizeof (device_id), device_id, NULL); // if (err != CL_SUCCESS) { // if (err == CL_INVALID_CONTEXT) // printf("ERROR: clGetContextInfo() => CL_INVALID_CONTEXT\n"); // if (err == CL_INVALID_VALUE) // printf("ERROR: clGetContextInfo() => CL_INVALID_VALUE\n"); // } // }//*/ char * s_likelihood_kernel = "likelihood_kernel"; char * s_sum_kernel = "sum_kernel"; char * s_normalize_weights_kernel = "normalize_weights_kernel"; char * s_find_index_kernel = "find_index_kernel"; kernel_likelihood = clCreateKernel(prog, s_likelihood_kernel, &err); if (err != CL_SUCCESS) { if (err == CL_INVALID_PROGRAM) printf("ERROR: clCreateKernel(likelihood_kernel) 0 => INVALID PROGRAM %d\n", err); if (err == CL_INVALID_PROGRAM_EXECUTABLE) printf("ERROR: clCreateKernel(likelihood_kernel) 0 => INVALID PROGRAM EXECUTABLE %d\n", err); if (err == CL_INVALID_KERNEL_NAME) printf("ERROR: clCreateKernel(likelihood_kernel) 0 => INVALID KERNEL NAME %d\n", err); if (err == CL_INVALID_KERNEL_DEFINITION) printf("ERROR: clCreateKernel(likelihood_kernel) 0 => INVALID KERNEL DEFINITION %d\n", err); if (err == CL_INVALID_VALUE) printf("ERROR: clCreateKernel(likelihood_kernel) 0 => INVALID CL_INVALID_VALUE %d\n", err); printf("ERROR: clCreateKernel(likelihood_kernel) failed.\n"); return -1; } kernel_sum = clCreateKernel(prog, s_sum_kernel, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateKernel(sum_kernel) 0 => %d\n", err); return -1; } kernel_normalize_weights = clCreateKernel(prog, s_normalize_weights_kernel, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateKernel(normalize_weights_kernel) 0 => %d\n", err); return -1; } kernel_find_index = clCreateKernel(prog, s_find_index_kernel, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateKernel(find_index_kernel) 0 => %d\n", err); return -1; } //initial likelihood to 0.0 double * likelihood = (double *) calloc(Nparticles + 1, sizeof (double)); double * arrayX = (double *) calloc(Nparticles, sizeof (double)); double * arrayY = (double *) calloc(Nparticles, sizeof (double)); double * xj = (double *) calloc(Nparticles, sizeof (double)); double * yj = (double *) calloc(Nparticles, sizeof (double)); double * CDF = (double *) calloc(Nparticles, sizeof(double)); //GPU copies of arrays cl_mem arrayX_GPU; cl_mem arrayY_GPU; cl_mem xj_GPU; cl_mem yj_GPU; cl_mem CDF_GPU; cl_mem likelihood_GPU; cl_mem I_GPU; cl_mem weights_GPU; cl_mem objxy_GPU; int * ind = (int*) calloc(countOnes, sizeof(int)); cl_mem ind_GPU; double * u = (double *) calloc(Nparticles, sizeof(double)); cl_mem u_GPU; cl_mem seed_GPU; cl_mem partial_sums; //OpenCL memory allocation arrayX_GPU = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof (double) *Nparticles, NULL, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateBuffer arrayX_GPU (size:%d) => %d\n", Nparticles, err); return -1; } arrayY_GPU = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof (double) *Nparticles, NULL, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateBuffer arrayY_GPU (size:%d) => %d\n", Nparticles, err); return -1; } xj_GPU = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof (double) *Nparticles, NULL, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateBuffer xj_GPU (size:%d) => %d\n", Nparticles, err); return -1; } yj_GPU = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof (double) *Nparticles, NULL, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateBuffer yj_GPU (size:%d) => %d\n", Nparticles, err); return -1; } CDF_GPU = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof (double) * Nparticles, NULL, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateBuffer CDF_GPU (size:%d) => %d\n", Nparticles, err); return -1; } u_GPU = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof (double) *Nparticles, NULL, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateBuffer u_GPU (size:%d) => %d\n", Nparticles, err); return -1; } likelihood_GPU = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof (double) *Nparticles, NULL, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateBuffer likelihood_GPU (size:%d) => %d\n", Nparticles, err); return -1; } weights_GPU = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof (double) *Nparticles, NULL, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateBuffer weights_GPU (size:%d) => %d\n", Nparticles, err); return -1; } I_GPU = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof (unsigned char) *IszX * IszY * Nfr, NULL, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateBuffer I_GPU (size:%d) => %d\n", IszX * IszY * Nfr, err); return -1; } objxy_GPU = clCreateBuffer(context, CL_MEM_READ_WRITE, 2*sizeof (int) *countOnes, NULL, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateBuffer objxy_GPU (size:%d) => %d\n", countOnes, err); return -1; } ind_GPU = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof (int) *countOnes * Nparticles, NULL, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateBuffer ind_GPU (size:%d) => %d\n", countOnes * Nparticles, err); return -1; } seed_GPU = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof (int) *Nparticles, NULL, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateBuffer seed_GPU (size:%d) => %d\n", Nparticles, err); return -1; } partial_sums = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof (double) * Nparticles + 1, likelihood, &err); if (err != CL_SUCCESS) { printf("ERROR: clCreateBuffer partial_sums (size:%d) => %d\n", Nparticles, err); return -1; } //Donnie - this loop is different because in this kernel, arrayX and arrayY // are set equal to xj before every iteration, so effectively, arrayX and // arrayY will be set to xe and ye before the first iteration. for (x = 0; x < Nparticles; x++) { xj[x] = xe; yj[x] = ye; } int k; //double * Ik = (double *)calloc(IszX*IszY, sizeof(double)); int indX, indY; //start send long long send_start = get_time(); //OpenCL memory copy err = clEnqueueWriteBuffer(cmd_queue, I_GPU, 1, 0, sizeof (unsigned char) *IszX * IszY*Nfr, I, 0, 0, 0); if (err != CL_SUCCESS) { printf("ERROR: clEnqueueWriteBuffer I_GPU (size:%d) => %d\n", IszX * IszY*Nfr, err); return -1; } err = clEnqueueWriteBuffer(cmd_queue, objxy_GPU, 1, 0, 2*sizeof (int) *countOnes, objxy, 0, 0, 0); if (err != CL_SUCCESS) { printf("ERROR: clEnqueueWriteBuffer objxy_GPU (size:%d) => %d\n", countOnes, err); return -1; } err = clEnqueueWriteBuffer(cmd_queue, weights_GPU, 1, 0, sizeof (double) *Nparticles, weights, 0, 0, 0); if (err != CL_SUCCESS) { printf("ERROR: clEnqueueWriteBuffer weights_GPU (size:%d) => %d\n", Nparticles, err); return -1; } err = clEnqueueWriteBuffer(cmd_queue, xj_GPU, 1, 0, sizeof (double) *Nparticles, xj, 0, 0, 0); if (err != CL_SUCCESS) { printf("ERROR: clEnqueueWriteBuffer arrayX_GPU (size:%d) => %d\n", Nparticles, err); return -1; } err = clEnqueueWriteBuffer(cmd_queue, yj_GPU, 1, 0, sizeof (double) *Nparticles, yj, 0, 0, 0); if (err != CL_SUCCESS) { printf("ERROR: clEnqueueWriteBuffer arrayY_GPU (size:%d) => %d\n", Nparticles, err); return -1; } err = clEnqueueWriteBuffer(cmd_queue, seed_GPU, 1, 0, sizeof (int) *Nparticles, seed, 0, 0, 0); if (err != CL_SUCCESS) { printf("ERROR: clEnqueueWriteBuffer seed_GPU (size:%d) => %d\n", Nparticles, err); return -1; } /********************************************************************** *********** E N D A L L O C A T E ******************************** *********************************************************************/ long long send_end = get_time(); printf("TIME TO SEND TO GPU: %f\n", elapsed_time(send_start, send_end)); int num_blocks = ceil((double) Nparticles / (double) threads_per_block); printf("threads_per_block=%d \n",threads_per_block); size_t local_work[3] = {threads_per_block, 1, 1}; size_t global_work[3] = {num_blocks*threads_per_block, 1, 1}; for (k = 1; k < Nfr; k++) { /****************** L I K E L I H O O D ************************************/ clSetKernelArg(kernel_likelihood, 0, sizeof (void *), (void*) &arrayX_GPU); clSetKernelArg(kernel_likelihood, 1, sizeof (void *), (void*) &arrayY_GPU); clSetKernelArg(kernel_likelihood, 2, sizeof (void *), (void*) &xj_GPU); clSetKernelArg(kernel_likelihood, 3, sizeof (void *), (void*) &yj_GPU); clSetKernelArg(kernel_likelihood, 4, sizeof (void *), (void*) &CDF_GPU); clSetKernelArg(kernel_likelihood, 5, sizeof (void *), (void*) &ind_GPU); clSetKernelArg(kernel_likelihood, 6, sizeof (void *), (void*) &objxy_GPU); clSetKernelArg(kernel_likelihood, 7, sizeof (void *), (void*) &likelihood_GPU); clSetKernelArg(kernel_likelihood, 8, sizeof (void *), (void*) &I_GPU); clSetKernelArg(kernel_likelihood, 9, sizeof (void *), (void*) &u_GPU); clSetKernelArg(kernel_likelihood, 10, sizeof (void *), (void*) &weights_GPU); clSetKernelArg(kernel_likelihood, 11, sizeof (cl_int), (void*) &Nparticles); clSetKernelArg(kernel_likelihood, 12, sizeof (cl_int), (void*) &countOnes); clSetKernelArg(kernel_likelihood, 13, sizeof (cl_int), (void*) &max_size); clSetKernelArg(kernel_likelihood, 14, sizeof (cl_int), (void*) &k); clSetKernelArg(kernel_likelihood, 15, sizeof (cl_int), (void*) &IszY); clSetKernelArg(kernel_likelihood, 16, sizeof (cl_int), (void*) &Nfr); clSetKernelArg(kernel_likelihood, 17, sizeof (void *), (void*) &seed_GPU); clSetKernelArg(kernel_likelihood, 18, sizeof (void *), (void*) &partial_sums); clSetKernelArg(kernel_likelihood, 19, threads_per_block * sizeof (double), NULL); //KERNEL FUNCTION CALL err = clEnqueueNDRangeKernel(cmd_queue, kernel_likelihood, 1, NULL, global_work, local_work, 0, 0, 0); clFinish(cmd_queue); if (err != CL_SUCCESS) { printf("ERROR: clEnqueueNDRangeKernel(kernel_likelihood)=>%d failed\n", err); //check_error(err, __FILE__, __LINE__); return -1; } /****************** E N D L I K E L I H O O D **********************/ /*************************** S U M ************************************/ clSetKernelArg(kernel_sum, 0, sizeof (void *), (void*) &partial_sums); clSetKernelArg(kernel_sum, 1, sizeof (cl_int), (void*) &Nparticles); //KERNEL FUNCTION CALL err = clEnqueueNDRangeKernel(cmd_queue, kernel_sum, 1, NULL, global_work, local_work, 0, 0, 0); clFinish(cmd_queue); if (err != CL_SUCCESS) { printf("ERROR: clEnqueueNDRangeKernel(kernel_sum)=>%d failed\n", err); //check_error(err, __FILE__, __LINE__); return -1; }/*************************** E N D S U M ****************************/ /**************** N O R M A L I Z E W E I G H T S *****************/ clSetKernelArg(kernel_normalize_weights, 0, sizeof (void *), (void*) &weights_GPU); clSetKernelArg(kernel_normalize_weights, 1, sizeof (cl_int), (void*) &Nparticles); clSetKernelArg(kernel_normalize_weights, 2, sizeof (void *), (void*) &partial_sums); //*/ clSetKernelArg(kernel_normalize_weights, 3, sizeof (void *), (void*) &CDF_GPU); clSetKernelArg(kernel_normalize_weights, 4, sizeof (void *), (void*) &u_GPU); clSetKernelArg(kernel_normalize_weights, 5, sizeof (void *), (void*) &seed_GPU); //KERNEL FUNCTION CALL err = clEnqueueNDRangeKernel(cmd_queue, kernel_normalize_weights, 1, NULL, global_work, local_work, 0, 0, 0); clFinish(cmd_queue); if (err != CL_SUCCESS) { printf("ERROR: clEnqueueNDRangeKernel(normalize_weights)=>%d failed\n", err); //check_error(err, __FILE__, __LINE__); return -1; } /************* E N D N O R M A L I Z E W E I G H T S ***********/ // ocl_print_double_array(cmd_queue, partial_sums, 40); // /********* I N T E R M E D I A T E R E S U L T S ***************/ // //OpenCL memory copying back from GPU to CPU memory err = clEnqueueReadBuffer(cmd_queue, arrayX_GPU, 1, 0, sizeof (double) *Nparticles, arrayX, 0, 0, 0); err = clEnqueueReadBuffer(cmd_queue, arrayY_GPU, 1, 0, sizeof (double) *Nparticles, arrayY, 0, 0, 0); err = clEnqueueReadBuffer(cmd_queue, weights_GPU, 1, 0, sizeof (double) *Nparticles, weights, 0, 0, 0); xe = 0; ye = 0; double total=0.0; // estimate the object location by expected values for (x = 0; x < Nparticles; x++) { // if( 0.0000000 < arrayX[x]*weights[x]) printf("arrayX[%d]:%f, arrayY[%d]:%f, weights[%d]:%0.10f\n",x,arrayX[x], x, arrayY[x], x, weights[x]); // printf("arrayX[%d]:%f | arrayY[%d]:%f | weights[%d]:%f\n", // x, arrayX[x], x, arrayY[x], x, weights[x]); xe += arrayX[x] * weights[x]; ye += arrayY[x] * weights[x]; total+= weights[x]; } printf("total weight: %lf\n", total); printf("XE: %lf\n", xe); printf("YE: %lf\n", ye); double distance = sqrt(pow((double) (xe - (int) roundDouble(IszY / 2.0)), 2) + pow((double) (ye - (int) roundDouble(IszX / 2.0)), 2)); printf("%lf\n", distance); // /********* E N D I N T E R M E D I A T E R E S U L T S ***************/ /******************** F I N D I N D E X ****************************/ //Set number of threads clSetKernelArg(kernel_find_index, 0, sizeof (void *), (void*) &arrayX_GPU); clSetKernelArg(kernel_find_index, 1, sizeof (void *), (void*) &arrayY_GPU); clSetKernelArg(kernel_find_index, 2, sizeof (void *), (void*) &CDF_GPU); clSetKernelArg(kernel_find_index, 3, sizeof (void *), (void*) &u_GPU); clSetKernelArg(kernel_find_index, 4, sizeof (void *), (void*) &xj_GPU); clSetKernelArg(kernel_find_index, 5, sizeof (void *), (void*) &yj_GPU); clSetKernelArg(kernel_find_index, 6, sizeof (void *), (void*) &weights_GPU); clSetKernelArg(kernel_find_index, 7, sizeof (cl_int), (void*) &Nparticles); //KERNEL FUNCTION CALL err = clEnqueueNDRangeKernel(cmd_queue, kernel_find_index, 1, NULL, global_work, local_work, 0, 0, 0); clFinish(cmd_queue); if (err != CL_SUCCESS) { printf("ERROR: clEnqueueNDRangeKernel(find_index)=>%d failed\n", err); //check_error(err, __FILE__, __LINE__); return -1; } /******************* E N D F I N D I N D E X ********************/ }//end loop //block till kernels are finished //clFinish(cmd_queue); long long back_time = get_time(); //OpenCL freeing of memory clReleaseProgram(prog); clReleaseMemObject(u_GPU); clReleaseMemObject(CDF_GPU); clReleaseMemObject(yj_GPU); clReleaseMemObject(xj_GPU); clReleaseMemObject(likelihood_GPU); clReleaseMemObject(I_GPU); clReleaseMemObject(objxy_GPU); clReleaseMemObject(ind_GPU); clReleaseMemObject(seed_GPU); clReleaseMemObject(partial_sums); long long free_time = get_time(); //OpenCL memory copying back from GPU to CPU memory err = clEnqueueReadBuffer(cmd_queue, arrayX_GPU, 1, 0, sizeof (double) *Nparticles, arrayX, 0, 0, 0); if (err != CL_SUCCESS) { printf("ERROR: Memcopy Out\n"); return -1; } long long arrayX_time = get_time(); err = clEnqueueReadBuffer(cmd_queue, arrayY_GPU, 1, 0, sizeof (double) *Nparticles, arrayY, 0, 0, 0); if (err != CL_SUCCESS) { printf("ERROR: Memcopy Out\n"); return -1; } long long arrayY_time = get_time(); err = clEnqueueReadBuffer(cmd_queue, weights_GPU, 1, 0, sizeof (double) *Nparticles, weights, 0, 0, 0); if (err != CL_SUCCESS) { printf("ERROR: Memcopy Out\n"); return -1; } long long back_end_time = get_time(); printf("GPU Execution: %lf\n", elapsed_time(send_end, back_time)); printf("FREE TIME: %lf\n", elapsed_time(back_time, free_time)); printf("SEND TO SEND BACK: %lf\n", elapsed_time(back_time, back_end_time)); printf("SEND ARRAY X BACK: %lf\n", elapsed_time(free_time, arrayX_time)); printf("SEND ARRAY Y BACK: %lf\n", elapsed_time(arrayX_time, arrayY_time)); printf("SEND WEIGHTS BACK: %lf\n", elapsed_time(arrayY_time, back_end_time)); xe = 0; ye = 0; // estimate the object location by expected values for (x = 0; x < Nparticles; x++) { xe += arrayX[x] * weights[x]; ye += arrayY[x] * weights[x]; } double distance = sqrt(pow((double) (xe - (int) roundDouble(IszY / 2.0)), 2) + pow((double) (ye - (int) roundDouble(IszX / 2.0)), 2)); //Output results FILE *fid; fid=fopen("output.txt", "w+"); if( fid == NULL ) { printf( "The file was not opened for writing\n" ); return -1; } fprintf(fid, "XE: %lf\n", xe); fprintf(fid, "YE: %lf\n", ye); fprintf(fid, "distance: %lf\n", distance); fclose(fid); //OpenCL freeing of memory clReleaseMemObject(weights_GPU); clReleaseMemObject(arrayY_GPU); clReleaseMemObject(arrayX_GPU); //free regular memory free(likelihood); free(arrayX); free(arrayY); free(xj); free(yj); free(CDF); free(ind); free(u); }
/** * The implementation of the particle filter using OpenMP for many frames * @see http://openmp.org/wp/ * @note This function is designed to work with a video of several frames. In addition, it references a provided MATLAB function which takes the video, the objxy matrix and the x and y arrays as arguments and returns the likelihoods * @param I The video to be run * @param IszX The x dimension of the video * @param IszY The y dimension of the video * @param Nfr The number of frames * @param seed The seed array used for random number generation * @param Nparticles The number of particles to be used */ int particleFilter(int * I, int IszX, int IszY, int Nfr, int * seed, int Nparticles){ int i, c; #ifdef HW XFcuda xcore; int Status; Status = XFcuda_Initialize(&xcore, 0); if (Status != XST_SUCCESS) { printf("Initialization failed\n"); return 1; // XST_FAILURE; } #endif int max_size = IszX*IszY*Nfr; //long long start = get_time(); //original particle centroid double xe = roundDouble(IszY/2.0); double ye = roundDouble(IszX/2.0); //expected object locations, compared to center int radius = 5; int diameter = radius*2 - 1; int * disk = (int *)malloc(diameter*diameter*sizeof(int)); strelDisk(disk, radius); int countOnes = 0; int x, y; for(x = 0; x < diameter; x++){ for(y = 0; y < diameter; y++){ if(disk[x*diameter + y] == 1) countOnes++; } } double * objxy = (double *)malloc(countOnes*2*sizeof(double)); getneighbors(disk, countOnes, objxy, radius); //long long get_neighbors = get_time(); //printf("TIME TO GET NEIGHBORS TOOK: %f\n", elapsed_time(start, get_neighbors)); //initial weights are all equal (1/Nparticles) double * weights = (double *)malloc(sizeof(double)*Nparticles); for(x = 0; x < Nparticles; x++){ weights[x] = 1/((double)(Nparticles)); } //long long get_weights = get_time(); //printf("TIME TO GET WEIGHTSTOOK: %f\n", elapsed_time(get_neighbors, get_weights)); //initial likelihood to 0.0 //printf("%d\n", Nparticles); double * likelihood = (double *)malloc(sizeof(double)*Nparticles); double * arrayX = (double *)malloc(sizeof(double)*Nparticles); double * arrayY = (double *)malloc(sizeof(double)*Nparticles); double * xj = (double *)malloc(sizeof(double)*Nparticles); double * yj = (double *)malloc(sizeof(double)*Nparticles); double * CDF = (double *)malloc(sizeof(double)*Nparticles); //GPU copies of arrays //double * arrayX_GPU; //double * arrayY_GPU; //double * xj_GPU; //double * yj_GPU; //double * CDF_GPU; int * ind = (int*)malloc(sizeof(int)*countOnes); double * u = (double *)malloc(sizeof(double)*Nparticles); //double * u_GPU; //CUDA memory allocation //check_error(cudaMalloc((void **) &arrayX_GPU, sizeof(double)*Nparticles)); //arrayX_GPU = (double*)malloc(sizeof(double)*Nparticles); //check_error(cudaMalloc((void **) &arrayY_GPU, sizeof(double)*Nparticles)); //arrayY_GPU = (double*)malloc(sizeof(double)*Nparticles); //check_error(cudaMalloc((void **) &xj_GPU, sizeof(double)*Nparticles)); //xj_GPU = (double*)malloc(sizeof(double)*Nparticles); //check_error(cudaMalloc((void **) &yj_GPU, sizeof(double)*Nparticles)); //yj_GPU = (double*)malloc(sizeof(double)*Nparticles); //check_error(cudaMalloc((void **) &CDF_GPU, sizeof(double)*Nparticles)); //CDF_GPU = (double*)malloc(sizeof(double)*Nparticles); //check_error(cudaMalloc((void **) &u_GPU, sizeof(double)*Nparticles)); //u_GPU = (double*)malloc(sizeof(double)*Nparticles); for(x = 0; x < Nparticles; x++){ arrayX[x] = xe; arrayY[x] = ye; } //Set number of threads int num_blocks = ceil((double) Nparticles/(double) threads_per_block); //printf("%d\n", num_blocks); dim3 grids, threads; grids.x = num_blocks; grids.y = 1; grids.z = 1; threads.x = threads_per_block; threads.y = 1; threads.z = 1; #ifdef HW XFcuda_SetNparticles(&xcore, Nparticles); XFcuda_SetGriddim_x(&xcore, grids.x); XFcuda_SetGriddim_y(&xcore, grids.y); //XFcuda_SetGriddim_z(&xcore, grids.z); XFcuda_SetBlockdim_x(&xcore, threads.x); //XFcuda_SetBlockdim_y(&xcore, threads.y); //XFcuda_SetBlockdim_z(&xcore, threads.z); XFcuda_SetArrayx_addr(&xcore, (u32)arrayX / sizeof(double)); XFcuda_SetArrayy_addr(&xcore, (u32)arrayY / sizeof(double)); XFcuda_SetCdf_addr(&xcore, (u32)CDF / sizeof(double)); XFcuda_SetU_addr(&xcore, (u32)u / sizeof(double)); XFcuda_SetXj_addr(&xcore, (u32)xj / sizeof(double)); XFcuda_SetYj_addr(&xcore, (u32)yj / sizeof(double)); #endif int k; //double * Ik = (double *)malloc(sizeof(double)*IszX*IszY); int indX, indY; double *result = (double *)malloc(3 * (Nfr - 1) * sizeof(double)); i = 0; for(k = 1; k < Nfr; k++){ //long long set_arrays = get_time(); //printf("TIME TO SET ARRAYS TOOK: %f\n", elapsed_time(get_weights, set_arrays)); //apply motion model //draws sample from motion model (random walk). The only prior information //is that the object moves 2x as fast as in the y direction for(x = 0; x < Nparticles; x++){ arrayX[x] = arrayX[x] + 1.0 + 5.0*randn(seed, x); arrayY[x] = arrayY[x] - 2.0 + 2.0*randn(seed, x); } //particle filter likelihood //long long error = get_time(); //printf("TIME TO SET ERROR TOOK: %f\n", elapsed_time(set_arrays, error)); for(x = 0; x < Nparticles; x++){ //compute the likelihood: remember our assumption is that you know // foreground and the background image intensity distribution. // Notice that we consider here a likelihood ratio, instead of // p(z|x). It is possible in this case. why? a hometask for you. //calc ind for(y = 0; y < countOnes; y++){ indX = roundDouble(arrayX[x]) + objxy[y*2 + 1]; indY = roundDouble(arrayY[x]) + objxy[y*2]; ind[y] = fabs(indX*IszY*Nfr + indY*Nfr + k); if(ind[y] >= max_size) ind[y] = 0; } likelihood[x] = calcLikelihoodSum(I, ind, countOnes); likelihood[x] = likelihood[x]/countOnes; } //long long likelihood_time = get_time(); //printf("TIME TO GET LIKELIHOODS TOOK: %f\n", elapsed_time(error, likelihood_time)); // update & normalize weights // using equation (63) of Arulampalam Tutorial for(x = 0; x < Nparticles; x++){ weights[x] = weights[x] * exp(likelihood[x]); } //long long exponential = get_time(); //printf("TIME TO GET EXP TOOK: %f\n", elapsed_time(likelihood_time, exponential)); double sumWeights = 0; for(x = 0; x < Nparticles; x++){ sumWeights += weights[x]; } //long long sum_time = get_time(); //printf("TIME TO SUM WEIGHTS TOOK: %f\n", elapsed_time(exponential, sum_time)); for(x = 0; x < Nparticles; x++){ weights[x] = weights[x]/sumWeights; } //long long normalize = get_time(); //printf("TIME TO NORMALIZE WEIGHTS TOOK: %f\n", elapsed_time(sum_time, normalize)); xe = 0; ye = 0; // estimate the object location by expected values for(x = 0; x < Nparticles; x++){ //printf("%f %f %f\n", arrayX[x], arrayY[x], weights[x]); xe += arrayX[x] * weights[x]; ye += arrayY[x] * weights[x]; } //long long move_time = get_time(); //printf("TIME TO MOVE OBJECT TOOK: %f\n", elapsed_time(normalize, move_time)); //printf("XE: %lf\n", xe); //printf("YE: %lf\n", ye); double distance = sqrt( pow((double)(xe-(int)roundDouble(IszY/2.0)),2) + pow((double)(ye-(int)roundDouble(IszX/2.0)),2) ); //printf("%lf\n", distance); result[i] = xe; result[i + 1] = ye; result[i + 2] = distance; i += 3; //display(hold off for now) //pause(hold off for now) //resampling CDF[0] = weights[0]; for(x = 1; x < Nparticles; x++){ CDF[x] = weights[x] + CDF[x-1]; } //long long cum_sum = get_time(); //printf("TIME TO CALC CUM SUM TOOK: %f\n", elapsed_time(move_time, cum_sum)); double u1 = (1/((double)(Nparticles)))*randu(seed, 0); for(x = 0; x < Nparticles; x++){ u[x] = u1 + x/((double)(Nparticles)); } //long long u_time = get_time(); //printf("TIME TO CALC U TOOK: %f\n", elapsed_time(cum_sum, u_time)); //long long start_copy = get_time(); //CUDA memory copying from CPU memory to GPU memory //cudaMemcpy(arrayX_GPU, arrayX, sizeof(double)*Nparticles, cudaMemcpyHostToDevice); //memcpy(arrayX_GPU, arrayX, sizeof(double)*Nparticles); //cudaMemcpy(arrayY_GPU, arrayY, sizeof(double)*Nparticles, cudaMemcpyHostToDevice); //memcpy(arrayY_GPU, arrayY, sizeof(double)*Nparticles); //cudaMemcpy(xj_GPU, xj, sizeof(double)*Nparticles, cudaMemcpyHostToDevice); //memcpy(xj_GPU, xj, sizeof(double)*Nparticles); //cudaMemcpy(yj_GPU, yj, sizeof(double)*Nparticles, cudaMemcpyHostToDevice); //memcpy(yj_GPU, yj, sizeof(double)*Nparticles); //cudaMemcpy(CDF_GPU, CDF, sizeof(double)*Nparticles, cudaMemcpyHostToDevice); //memcpy(CDF_GPU, CDF, sizeof(double)*Nparticles); //cudaMemcpy(u_GPU, u, sizeof(double)*Nparticles, cudaMemcpyHostToDevice); //memcpy(u_GPU, u, sizeof(double)*Nparticles); //long long end_copy = get_time(); //Xil_DCacheDisable(); #ifdef HW Xil_DCacheDisable(); XFcuda_SetEn_fcuda1(&xcore, 1); XFcuda_Start(&xcore); while (!XFcuda_IsDone(&xcore)); Xil_DCacheEnable(); #else //KERNEL FUNCTION CALL int j; for(j = 0; j < Nparticles; j++){ x = findIndex(CDF, Nparticles, u[j]); if(x == -1) x = Nparticles-1; xj[j] = arrayX[x]; yj[j] = arrayY[x]; } #endif //cudaThreadSynchronize(); //long long start_copy_back = get_time(); //CUDA memory copying back from GPU to CPU memory //cudaMemcpy(yj, yj_GPU, sizeof(double)*Nparticles, cudaMemcpyDeviceToHost); //memcpy(yj, yj_GPU, sizeof(double)*Nparticles); //cudaMemcpy(xj, xj_GPU, sizeof(double)*Nparticles, cudaMemcpyDeviceToHost); //memcpy(xj, xj_GPU, sizeof(double)*Nparticles); //long long end_copy_back = get_time(); //printf("SENDING TO GPU TOOK: %lf\n", elapsed_time(start_copy, end_copy)); //printf("CUDA EXEC TOOK: %lf\n", elapsed_time(end_copy, start_copy_back)); //printf("SENDING BACK FROM GPU TOOK: %lf\n", elapsed_time(start_copy_back, end_copy_back)); //long long xyj_time = get_time(); //printf("TIME TO CALC NEW ARRAY X AND Y TOOK: %f\n", elapsed_time(u_time, xyj_time)); for(x = 0; x < Nparticles; x++){ //reassign arrayX and arrayY arrayX[x] = xj[x]; arrayY[x] = yj[x]; weights[x] = 1/((double)(Nparticles)); } //long long reset = get_time(); //printf("TIME TO RESET WEIGHTS TOOK: %f\n", elapsed_time(xyj_time, reset)); } //CUDA freeing of memory /*cudaFree(u_GPU); cudaFree(CDF_GPU); cudaFree(yj_GPU); cudaFree(xj_GPU); cudaFree(arrayY_GPU); cudaFree(arrayX_GPU);*/ /* free(u_GPU); free(CDF_GPU); free(yj_GPU); free(xj_GPU); free(arrayY_GPU); free(arrayX_GPU); */ //free memory free(disk); free(objxy); free(weights); free(likelihood); free(arrayX); free(arrayY); free(xj); free(yj); free(CDF); free(u); free(ind); /* FILE *fp = fopen("cuda/gold_output_naive.txt", "r"); if (fp == NULL) { printf("Cannot open file.\n"); free(result); return 0; } char buffer[50]; double gold_val; for (i = 0; i < 3 * (Nfr - 1); i++) { if (feof(fp)) { printf("Unexpected end of file.\n"); free(result); return 0; } fgets(buffer, sizeof(buffer), fp); sscanf(buffer, "%lf\n", &gold_val); if (gold_val - result[i] < -EPSILON || gold_val - result[i] > EPSILON) { printf("Mismatch result at %i: gold = %f, result = %f\n", i, gold_val, result[i]); free(result); return 0; } } free(result); */ #ifdef VERIFY for (i = 0; i < 3 * (Nfr - 1); i++) { printf("index %d: %f\n", i, result[i]); } for (i = 0; i < 3 * (Nfr - 1); i++) { if (fabs(gold_output[i] - result[i]) > EPSILON) { printf("Mismatch result at %i: gold = %f, result = %f\n", i, gold_output[i], result[i]); free(result); return 0; } } #endif free(result); return 1; }
void writePecStitches(EmbPattern* pattern, EmbFile* file, const char* fileName) { EmbStitchList* tempStitches = 0; EmbRect bounds; unsigned char image[38][48]; int i, flen, currentThreadCount, graphicsOffsetLocation, graphicsOffsetValue, height, width; double xFactor, yFactor; const char* forwardSlashPos = strrchr(fileName, '/'); const char* backSlashPos = strrchr(fileName, '\\'); const char* dotPos = strrchr(fileName, '.'); const char* start = 0; if(!pattern) { embLog_error("format-pec.c writePecStitches(), pattern argument is null\n"); return; } if(!file) { embLog_error("format-pec.c writePecStitches(), file argument is null\n"); return; } if(!fileName) { embLog_error("format-pec.c writePecStitches(), fileName argument is null\n"); return; } if(forwardSlashPos) { start = forwardSlashPos + 1; } if(backSlashPos && backSlashPos > start) { start = backSlashPos + 1; } if(!start) { start = fileName; } binaryWriteBytes(file, "LA:", 3); flen = (int)(dotPos - start); while(start < dotPos) { binaryWriteByte(file, (unsigned char)*start); start++; } for(i = 0; i < (int)(16-flen); i++) { binaryWriteByte(file, (unsigned char)0x20); } binaryWriteByte(file, 0x0D); for(i = 0; i < 12; i++) { binaryWriteByte(file, (unsigned char)0x20); } binaryWriteByte(file, (unsigned char)0xFF); binaryWriteByte(file, (unsigned char)0x00); binaryWriteByte(file, (unsigned char)0x06); binaryWriteByte(file, (unsigned char)0x26); for(i = 0; i < 12; i++) { binaryWriteByte(file, (unsigned char)0x20); } currentThreadCount = embThreadList_count(pattern->threadList); binaryWriteByte(file, (unsigned char)(currentThreadCount-1)); for(i = 0; i < currentThreadCount; i++) { binaryWriteByte(file, (unsigned char)embThread_findNearestColorInArray(embThreadList_getAt(pattern->threadList, i).color, (EmbThread*)pecThreads, pecThreadCount)); } for(i = 0; i < (int)(0x1CF - currentThreadCount); i++) { binaryWriteByte(file, (unsigned char)0x20); } binaryWriteShort(file, (short)0x0000); graphicsOffsetLocation = embFile_tell(file); /* placeholder bytes to be overwritten */ binaryWriteByte(file, (unsigned char)0x00); binaryWriteByte(file, (unsigned char)0x00); binaryWriteByte(file, (unsigned char)0x00); binaryWriteByte(file, (unsigned char)0x31); binaryWriteByte(file, (unsigned char)0xFF); binaryWriteByte(file, (unsigned char)0xF0); bounds = embPattern_calcBoundingBox(pattern); height = roundDouble(embRect_height(bounds)); width = roundDouble(embRect_width(bounds)); /* write 2 byte x size */ binaryWriteShort(file, (short)width); /* write 2 byte y size */ binaryWriteShort(file, (short)height); /* Write 4 miscellaneous int16's */ binaryWriteShort(file, (short)0x1E0); binaryWriteShort(file, (short)0x1B0); binaryWriteUShortBE(file, (unsigned short)(0x9000 | -roundDouble(bounds.left))); binaryWriteUShortBE(file, (unsigned short)(0x9000 | -roundDouble(bounds.top))); pecEncode(file, pattern); graphicsOffsetValue = embFile_tell(file) - graphicsOffsetLocation + 2; embFile_seek(file, graphicsOffsetLocation, SEEK_SET); binaryWriteByte(file, (unsigned char)(graphicsOffsetValue & 0xFF)); binaryWriteByte(file, (unsigned char)((graphicsOffsetValue >> 8) & 0xFF)); binaryWriteByte(file, (unsigned char)((graphicsOffsetValue >> 16) & 0xFF)); embFile_seek(file, 0x00, SEEK_END); /* Writing all colors */ clearImage(image); tempStitches = pattern->stitchList; yFactor = 32.0 / height; xFactor = 42.0 / width; while(tempStitches->next) { int x = roundDouble((tempStitches->stitch.xx - bounds.left) * xFactor) + 3; int y = roundDouble((tempStitches->stitch.yy - bounds.top) * yFactor) + 3; image[y][x] = 1; tempStitches = tempStitches->next; } writeImage(file, image); /* Writing each individual color */ tempStitches = pattern->stitchList; for(i = 0; i < currentThreadCount; i++) { clearImage(image); while(tempStitches->next) { int x = roundDouble((tempStitches->stitch.xx - bounds.left) * xFactor) + 3; int y = roundDouble((tempStitches->stitch.yy - bounds.top) * yFactor) + 3; if(tempStitches->stitch.flags & STOP) { tempStitches = tempStitches->next; break; } image[y][x] = 1; tempStitches = tempStitches->next; } writeImage(file, image); } }
/*! Writes the data from \a pattern to a file with the given \a fileName. * Returns \c true if successful, otherwise returns \c false. */ int writePcs(EmbPattern* pattern, const char* fileName) { EmbStitchList* pointer = 0; EmbThreadList* threadPointer = 0; EmbFile* file = 0; int i = 0; unsigned char colorCount = 0; double xx = 0.0, yy = 0.0; if(!pattern) { embLog_error("format-pcs.c writePcs(), pattern argument is null\n"); return 0; } if(!fileName) { embLog_error("format-pcs.c writePcs(), fileName argument is null\n"); return 0; } if(!embStitchList_count(pattern->stitchList)) { embLog_error("format-pcs.c writePcs(), pattern contains no stitches\n"); return 0; } /* Check for an END stitch and add one if it is not present */ if(pattern->lastStitch->stitch.flags != END) embPattern_addStitchRel(pattern, 0, 0, END, 1); file = embFile_open(fileName, "wb"); if(!file) { embLog_error("format-pcs.c writePcs(), cannot open %s for writing\n", fileName); return 0; } binaryWriteByte(file, (unsigned char)'2'); binaryWriteByte(file, 3); /* TODO: select hoop size defaulting to Large PCS hoop */ colorCount = (unsigned char)embThreadList_count(pattern->threadList); binaryWriteUShort(file, (unsigned short)colorCount); threadPointer = pattern->threadList; i = 0; while(threadPointer) { EmbColor color = threadPointer->thread.color; binaryWriteByte(file, color.r); binaryWriteByte(file, color.g); binaryWriteByte(file, color.b); binaryWriteByte(file, 0); threadPointer = threadPointer->next; i++; } for(; i < 16; i++) { binaryWriteUInt(file, 0); /* write remaining colors to reach 16 */ } binaryWriteUShort(file, (unsigned short)embStitchList_count(pattern->stitchList)); /* write stitches */ xx = yy = 0; pointer = pattern->stitchList; while(pointer) { pcsEncode(file, roundDouble(pointer->stitch.xx * 10.0), roundDouble(pointer->stitch.yy * 10.0), pointer->stitch.flags); pointer = pointer->next; } embFile_close(file); return 1; }
/** * setCountry(): Set the current country code. * @param newCountry New country code. */ void Options::setCountry(const int newCountry) { unsigned char Reg_1[0x200]; Flag_Clr_Scr = 1; Country = newCountry; switch (Country) { default: case -1: // Auto-detect. if (Genesis_Started || _32X_Started) Detect_Country_Genesis(); else if (SegaCD_Started) Detect_Country_SegaCD(); break; case 0: // Japan (NTSC) Game_Mode = 0; CPU_Mode = 0; break; case 1: // USA (NTSC) Game_Mode = 1; CPU_Mode = 0; break; case 2: // Europe (PAL) Game_Mode = 1; CPU_Mode = 1; break; case 3: // Japan (PAL) Game_Mode = 0; CPU_Mode = 1; break; } // TODO: Combine this with gens.cpp:Set_Clock_Freq(). if (CPU_Mode) { CPL_Z80 = roundDouble((((double)CLOCK_PAL / 15.0) / 50.0) / 312.0); CPL_M68K = roundDouble((((double)CLOCK_PAL / 7.0) / 50.0) / 312.0); CPL_MSH2 = roundDouble(((((((double)CLOCK_PAL / 7.0) * 3.0) / 50.0) / 312.0) * (double)MSH2_Speed) / 100.0); CPL_SSH2 = roundDouble(((((((double)CLOCK_PAL / 7.0) * 3.0) / 50.0) / 312.0) * (double)SSH2_Speed) / 100.0); VDP_Num_Lines = 312; VDP_Status |= 0x0001; _32X_VDP.Mode &= ~0x8000; CD_Access_Timer = 2080; Timer_Step = 136752; } else { CPL_Z80 = roundDouble((((double)CLOCK_NTSC / 15.0) / 60.0) / 262.0); CPL_M68K = roundDouble((((double)CLOCK_NTSC / 7.0) / 60.0) / 262.0); CPL_MSH2 = roundDouble(((((((double)CLOCK_NTSC / 7.0) * 3.0) / 60.0) / 262.0) * (double)MSH2_Speed) / 100.0); CPL_SSH2 = roundDouble(((((((double) CLOCK_NTSC / 7.0) * 3.0) / 60.0) / 262.0) * (double)SSH2_Speed) / 100.0); VDP_Num_Lines = 262; VDP_Status &= 0xFFFE; _32X_VDP.Mode |= 0x8000; CD_Access_Timer = 2096; Timer_Step = 135708; } if (audio->enabled()) { PSG_Save_State(); YM2612_Save(Reg_1); audio->endSound(); audio->setEnabled(false); if (CPU_Mode) { YM2612_Init(CLOCK_PAL / 7, audio->soundRate(), YM2612_Improv); PSG_Init(CLOCK_PAL / 15, audio->soundRate()); } else { YM2612_Init(CLOCK_NTSC / 7, audio->soundRate(), YM2612_Improv); PSG_Init(CLOCK_NTSC / 15, audio->soundRate()); } if (SegaCD_Started) Set_Rate_PCM(audio->soundRate()); YM2612_Restore (Reg_1); PSG_Restore_State(); if (!audio->initSound()) return; audio->setEnabled(true); audio->playSound(); } if (Game_Mode) { if (CPU_Mode) MESSAGE_L("Europe system (50 FPS)", "Europe system (50 FPS)", 1500); else MESSAGE_L("USA system (60 FPS)", "USA system (60 FPS)", 1500); } else { if (CPU_Mode) MESSAGE_L("Japan system (50 FPS)", "Japan system (50 FPS)", 1500); else MESSAGE_L("Japan system (60 FPS)", "Japan system (60 FPS)", 1500); } setGameName(); return; }
int main(void) { srand( time( NULL ) ); char op; double double1; double double2; int int1; int int2; printf( "%s\n", "add ( + ) + double double" ); printf( "%s\n", "subtract ( - ) - double double" ); printf( "%s\n", "multiply ( * ) * double double" ); printf( "%s\n", "divide ( / ) / double double" ); printf( "%s\n", "power ( ^ ) ^ double int" ); printf( "%s\n", "exponential ( e ) e int" ); printf( "%s\n", "factorial ( ! ) ! int" ); printf( "%s\n", "random range ( r ) r int int" ); printf( "%s\n", "sum range ( s ) s int int" ); printf( "%s\n", "round ( ~ ) ~ double" ); printf( "%s\n", "roundup ( ' ) ` double" ); printf( "%s\n", "rounddown ( _ ) _ double" ); printf( "%s\n", "minimum ( < ) < double double" ); printf( "%s\n", "maximum ( > ) > double double" ); printf( "%s\n", "quit ( q ) q" ); do { scanf( " %c", &op ); switch ( op ) { case '+': scanf( "%lf%lf", &double1, &double2 ); printf( "%.2f\n", double1 + double2 ); break; case '-': scanf( "%lf%lf", &double1, &double2 ); printf( "%.2f\n", double1 - double2 ); break; case '*': scanf( "%lf%lf", &double1, &double2 ); printf( "%.2f\n", double1 * double2 ); break; case '/': scanf( "%lf%lf", &double1, &double2 ); if ( double2 != 0 ) { printf( "%.2f\n", double1 / double2 ); } else { printf( "%s\n", "Error: Dividing by 0" ); } break; case '^': scanf( "%lf%d", &double1, &int1 ); printf( "%.4f\n", power( double1, int1 ) ); break; case 'e': scanf( "%d", &int1 ); printf( "%lf\n", power( 2.71828182846, int1 ) ); break; case '!': scanf( "%d", &int1 ); printf( "%d\n", factorial( int1 ) ); break; case 'r': scanf( "%d%d", &int1, &int2 ); printf( "%d\n", randomRange( int1, int2 ) ); break; case 's': scanf( "%d%d", &int1, &int2 ); printf( "%d\n", sumRange( int1, int2 ) ); break; case '~': scanf( "%lf", &double1 ); printf( "%d\n", roundDouble( double1 ) ); break; case '`': scanf( "%lf", &double1 ); printf( "%d\n", (int) double1 + 1 ); break; case '_': scanf( "%lf", &double1 ); printf( "%d\n", (int) double1 ); break; case '<': scanf( "%lf%lf", &double1, &double2 ); if ( double1 < double2 ) { printf( "%.2f\n", double1 ); } else { printf( "%.2f\n", double2 ); } break; case '>': scanf( "%lf%lf", &double1, &double2 ); if ( double1 > double2 ) { printf( "%.2f\n", double1 ); } else { printf( "%.2f\n", double2 ); } break; case 'q': printf( "%s\n", "Good-bye." ); break; default: printf( "%s\n", "Invalid input." ); break; } } while(op !='q'); }
int writeVip(EmbPattern* pattern, const char* fileName) { EmbRect boundingRect; int stitchCount, minColors, patternColor; int attributeSize = 0; int xCompressedSize = 0; int yCompressedSize = 0; double previousX = 0; double previousY = 0; unsigned char* xValues, *yValues, *attributeValues; EmbStitchList* pointer; double xx = 0.0; double yy = 0.0; int flags = 0; int i = 0; unsigned char* attributeCompressed, *xCompressed, *yCompressed, *decodedColors, *encodedColors; unsigned char prevByte = 0; EmbThreadList *colorPointer; FILE* file = fopen(fileName, "wb"); if(file == 0) { /*TODO: set status here "Error opening HUS file for write:" */ return 0; } stitchCount = embStitch_count(pattern->stitchList); minColors = embThread_count(pattern->threadList); decodedColors = (unsigned char *) malloc(minColors* 4 *sizeof(unsigned char)); encodedColors = (unsigned char *) malloc(minColors* 4 *sizeof(unsigned char)); /* embPattern_correctForMaxStitchLength(pattern, 0x7F, 0x7F); */ patternColor = minColors; if(minColors > 24) minColors = 24; binaryWriteUInt(file, 0x0190FC5D); binaryWriteUInt(file, stitchCount); binaryWriteUInt(file, minColors); boundingRect = embPattern_calcBoundingBox(pattern); binaryWriteShort(file, (short) roundDouble(boundingRect.right * 10.0)); binaryWriteShort(file, (short) -roundDouble(boundingRect.top * 10.0 - 1.0)); binaryWriteShort(file, (short) roundDouble(boundingRect.left * 10.0)); binaryWriteShort(file, (short) -roundDouble(boundingRect.bottom * 10.0 - 1.0)); binaryWriteUInt(file, 0x38 + (minColors << 3)); xValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount)); yValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount)); attributeValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount)); pointer = pattern->stitchList; while(pointer) { xx = pointer->stitch.xx; yy = pointer->stitch.yy; flags = pointer->stitch.flags; xValues[i] = vipEncodeByte((xx - previousX) * 10.0); previousX = xx; yValues[i] = vipEncodeByte((yy - previousY) * 10.0); previousY = yy; attributeValues[i] = vipEncodeStitchType(flags); pointer = pointer->next; i++; } attributeCompressed = vipCompressData(attributeValues, stitchCount, &attributeSize); xCompressed = vipCompressData(xValues, stitchCount, &xCompressedSize); yCompressed = vipCompressData(yValues, stitchCount, &yCompressedSize); binaryWriteUInt(file, (unsigned int) (0x38 + (minColors << 3) + attributeSize)); binaryWriteUInt(file, (unsigned int) (0x38 + (minColors << 3) + attributeSize + xCompressedSize)); binaryWriteUInt(file, 0x00000000); binaryWriteUInt(file, 0x00000000); binaryWriteUShort(file, 0x0000); binaryWriteInt(file, minColors << 2); colorPointer = pattern->threadList; for (i = 0; i < minColors; i++) { int byteChunk = i << 2; EmbColor currentColor = colorPointer->thread.color; decodedColors[byteChunk] = currentColor.r; decodedColors[byteChunk + 1] = currentColor.g; decodedColors[byteChunk + 2] = currentColor.b; decodedColors[byteChunk + 3] = 0x01; colorPointer = colorPointer->next; } for (i = 0; i < minColors << 2; ++i) { unsigned char tmpByte = (unsigned char) (decodedColors[i] ^ vipDecodingTable[i]); prevByte = (unsigned char) (tmpByte ^ prevByte); binaryWriteByte(file, prevByte); } for (i = 0; i <= minColors; i++) { binaryWriteInt(file, 1); } binaryWriteUInt(file, 0); /* string length */ binaryWriteShort(file, 0); binaryWriteBytes(file, (char*) attributeCompressed, attributeSize); binaryWriteBytes(file, (char*) xCompressed, xCompressedSize); binaryWriteBytes(file, (char*) yCompressed, yCompressedSize); fclose(file); return 1; }
static unsigned char vipEncodeByte(double f) { return (unsigned char)(int)roundDouble(f); }
/*! Writes the data from \a pattern to a file with the given \a fileName. * Returns \c true if successful, otherwise returns \c false. */ int writeDst(EmbPattern* pattern, const char* fileName) { EmbRect boundingRect; FILE* file = 0; int xx, yy, dx, dy, flags; int i; int co = 1, st = 0; int ax, ay, mx, my; char* pd = 0; EmbStitchList* pointer = 0; if(!pattern) { embLog_error("format-dst.c writeDst(), pattern argument is null\n"); return 0; } if(!fileName) { embLog_error("format-dst.c writeDst(), fileName argument is null\n"); return 0; } file = fopen(fileName, "wb"); if(!file) { embLog_error("format-dst.c writeDst(), cannot open %s for writing\n", fileName); return 0; } embPattern_correctForMaxStitchLength(pattern, 12.1, 12.1); xx = yy = 0; co = 1; co = embThreadList_count(pattern->threadList); st = 0; st = embStitchList_count(pattern->stitchList); flags = NORMAL; boundingRect = embPattern_calcBoundingBox(pattern); /* TODO: review the code below if (pattern->get_variable("design_name") != NULL) { char *la = stralloccopy(pattern->get_variable("design_name")); if (strlen(la)>16) la[16]='\0'; fprintf(file,"LA:%-16s\x0d",la); free (la); } else { */ fprintf(file, "LA:%-16s\x0d", "Untitled"); /*} */ fprintf(file, "ST:%7d\x0d", st); fprintf(file, "CO:%3d\x0d", co - 1); /* number of color changes, not number of colors! */ fprintf(file, "+X:%5d\x0d", (int)(boundingRect.right * 10.0)); fprintf(file, "-X:%5d\x0d", (int)(fabs(boundingRect.left) * 10.0)); fprintf(file, "+Y:%5d\x0d", (int)(boundingRect.bottom * 10.0)); fprintf(file, "-Y:%5d\x0d", (int)(fabs(boundingRect.top) * 10.0)); ax = ay = mx = my = 0; /* TODO: review the code below */ /*ax=pattern->get_variable_int("ax"); */ /* will return 0 if not defined */ /*ay=pattern->get_variable_int("ay"); */ /*mx=pattern->get_variable_int("mx"); */ /*my=pattern->get_variable_int("my"); */ /*pd=pattern->get_variable("pd");*/ /* will return null pointer if not defined */ pd = 0; if(pd == 0 || strlen(pd) != 6) { /* pd is not valid, so fill in a default consisting of "******" */ pd = "******"; }; fprintf(file, "AX:+%5d\x0d", ax); fprintf(file, "AY:+%5d\x0d", ay); fprintf(file, "MX:+%5d\x0d", mx); fprintf(file, "MY:+%5d\x0d", my); fprintf(file, "PD:%6s\x0d", pd); binaryWriteByte(file, 0x1a); /* 0x1a is the code for end of section. */ /* pad out header to proper length */ for(i = 125; i < 512; i++) { fprintf(file, " "); } /* write stitches */ xx = yy = 0; pointer = pattern->stitchList; while(pointer) { /* convert from mm to 0.1mm for file format */ dx = roundDouble(pointer->stitch.xx * 10.0) - xx; dy = roundDouble(pointer->stitch.yy * 10.0) - yy; xx = roundDouble(pointer->stitch.xx * 10.0); yy = roundDouble(pointer->stitch.yy * 10.0); flags = pointer->stitch.flags; encode_record(file, dx, dy, flags); pointer = pointer->next; } binaryWriteByte(file, 0xA1); /* finish file with a terminator character */ binaryWriteShort(file, 0); fclose(file); return 1; }
/** * The implementation of the particle filter using OpenMP for many frames * @see http://openmp.org/wp/ * @note This function is designed to work with a video of several frames. In addition, it references a provided MATLAB function which takes the video, the objxy matrix and the x and y arrays as arguments and returns the likelihoods * @param I The video to be run * @param IszX The x dimension of the video * @param IszY The y dimension of the video * @param Nfr The number of frames * @param seed The seed array used for random number generation * @param Nparticles The number of particles to be used */ void particleFilter(int * I, int IszX, int IszY, int Nfr, int * seed, int Nparticles){ int max_size = IszX*IszY*Nfr; long long start = get_time(); //original particle centroid double xe = roundDouble(IszY/2.0); double ye = roundDouble(IszX/2.0); //expected object locations, compared to center int radius = 5; int diameter = radius*2 - 1; int * disk = (int *)malloc(diameter*diameter*sizeof(int)); strelDisk(disk, radius); int countOnes = 0; int x, y; for(x = 0; x < diameter; x++){ for(y = 0; y < diameter; y++){ if(disk[x*diameter + y] == 1) countOnes++; } } double * objxy = (double *)malloc(countOnes*2*sizeof(double)); getneighbors(disk, countOnes, objxy, radius); long long get_neighbors = get_time(); printf("TIME TO GET NEIGHBORS TOOK: %f\n", elapsed_time(start, get_neighbors)); //initial weights are all equal (1/Nparticles) double * weights = (double *)malloc(sizeof(double)*Nparticles); #pragma omp parallel for shared(weights, Nparticles) private(x) for(x = 0; x < Nparticles; x++){ weights[x] = 1/((double)(Nparticles)); } long long get_weights = get_time(); printf("TIME TO GET WEIGHTSTOOK: %f\n", elapsed_time(get_neighbors, get_weights)); //initial likelihood to 0.0 double * likelihood = (double *)malloc(sizeof(double)*Nparticles); double * arrayX = (double *)malloc(sizeof(double)*Nparticles); double * arrayY = (double *)malloc(sizeof(double)*Nparticles); double * xj = (double *)malloc(sizeof(double)*Nparticles); double * yj = (double *)malloc(sizeof(double)*Nparticles); double * CDF = (double *)malloc(sizeof(double)*Nparticles); double * u = (double *)malloc(sizeof(double)*Nparticles); int * ind = (int*)malloc(sizeof(int)*countOnes*Nparticles); #pragma omp parallel for shared(arrayX, arrayY, xe, ye) private(x) for(x = 0; x < Nparticles; x++){ arrayX[x] = xe; arrayY[x] = ye; } int k; printf("TIME TO SET ARRAYS TOOK: %f\n", elapsed_time(get_weights, get_time())); int indX, indY; for(k = 1; k < Nfr; k++){ long long set_arrays = get_time(); //apply motion model //draws sample from motion model (random walk). The only prior information //is that the object moves 2x as fast as in the y direction #pragma omp parallel for shared(arrayX, arrayY, Nparticles, seed) private(x) for(x = 0; x < Nparticles; x++){ arrayX[x] += 1 + 5*randn(seed, x); arrayY[x] += -2 + 2*randn(seed, x); } long long error = get_time(); printf("TIME TO SET ERROR TOOK: %f\n", elapsed_time(set_arrays, error)); //particle filter likelihood #pragma omp parallel for shared(likelihood, I, arrayX, arrayY, objxy, ind) private(x, y, indX, indY) for(x = 0; x < Nparticles; x++){ //compute the likelihood: remember our assumption is that you know // foreground and the background image intensity distribution. // Notice that we consider here a likelihood ratio, instead of // p(z|x). It is possible in this case. why? a hometask for you. //calc ind for(y = 0; y < countOnes; y++){ indX = roundDouble(arrayX[x]) + objxy[y*2 + 1]; indY = roundDouble(arrayY[x]) + objxy[y*2]; ind[x*countOnes + y] = fabs(indX*IszY*Nfr + indY*Nfr + k); if(ind[x*countOnes + y] >= max_size) ind[x*countOnes + y] = 0; } likelihood[x] = 0; for(y = 0; y < countOnes; y++) likelihood[x] += (pow((I[ind[x*countOnes + y]] - 100),2) - pow((I[ind[x*countOnes + y]]-228),2))/50.0; likelihood[x] = likelihood[x]/((double) countOnes); } long long likelihood_time = get_time(); printf("TIME TO GET LIKELIHOODS TOOK: %f\n", elapsed_time(error, likelihood_time)); // update & normalize weights // using equation (63) of Arulampalam Tutorial #pragma omp parallel for shared(Nparticles, weights, likelihood) private(x) for(x = 0; x < Nparticles; x++){ weights[x] = weights[x] * exp(likelihood[x]); } long long exponential = get_time(); printf("TIME TO GET EXP TOOK: %f\n", elapsed_time(likelihood_time, exponential)); double sumWeights = 0; #pragma omp parallel for private(x) reduction(+:sumWeights) for(x = 0; x < Nparticles; x++){ sumWeights += weights[x]; } long long sum_time = get_time(); printf("TIME TO SUM WEIGHTS TOOK: %f\n", elapsed_time(exponential, sum_time)); #pragma omp parallel for shared(sumWeights, weights) private(x) for(x = 0; x < Nparticles; x++){ weights[x] = weights[x]/sumWeights; } long long normalize = get_time(); printf("TIME TO NORMALIZE WEIGHTS TOOK: %f\n", elapsed_time(sum_time, normalize)); xe = 0; ye = 0; // estimate the object location by expected values #pragma omp parallel for private(x) reduction(+:xe, ye) for(x = 0; x < Nparticles; x++){ xe += arrayX[x] * weights[x]; ye += arrayY[x] * weights[x]; } long long move_time = get_time(); printf("TIME TO MOVE OBJECT TOOK: %f\n", elapsed_time(normalize, move_time)); printf("XE: %lf\n", xe); printf("YE: %lf\n", ye); double distance = sqrt( pow((double)(xe-(int)roundDouble(IszY/2.0)),2) + pow((double)(ye-(int)roundDouble(IszX/2.0)),2) ); printf("%lf\n", distance); //display(hold off for now) //pause(hold off for now) //resampling CDF[0] = weights[0]; for(x = 1; x < Nparticles; x++){ CDF[x] = weights[x] + CDF[x-1]; } long long cum_sum = get_time(); printf("TIME TO CALC CUM SUM TOOK: %f\n", elapsed_time(move_time, cum_sum)); double u1 = (1/((double)(Nparticles)))*randu(seed, 0); #pragma omp parallel for shared(u, u1, Nparticles) private(x) for(x = 0; x < Nparticles; x++){ u[x] = u1 + x/((double)(Nparticles)); } long long u_time = get_time(); printf("TIME TO CALC U TOOK: %f\n", elapsed_time(cum_sum, u_time)); int j, i; #pragma omp parallel for shared(CDF, Nparticles, xj, yj, u, arrayX, arrayY) private(i, j) for(j = 0; j < Nparticles; j++){ i = findIndex(CDF, Nparticles, u[j]); if(i == -1) i = Nparticles-1; xj[j] = arrayX[i]; yj[j] = arrayY[i]; } long long xyj_time = get_time(); printf("TIME TO CALC NEW ARRAY X AND Y TOOK: %f\n", elapsed_time(u_time, xyj_time)); //reassign arrayX and arrayY arrayX = xj; arrayY = yj; //#pragma omp parallel for shared(weights, Nparticles) private(x) for(x = 0; x < Nparticles; x++){ weights[x] = 1/((double)(Nparticles)); } long long reset = get_time(); printf("TIME TO RESET WEIGHTS TOOK: %f\n", elapsed_time(xyj_time, reset)); } free(disk); free(objxy); free(weights); free(likelihood); free(arrayX); free(arrayY); free(CDF); free(u); free(ind); }
/*! Writes the data from \a pattern to a file with the given \a fileName. * Returns \c true if successful, otherwise returns \c false. */ int writeVip(EmbPattern* pattern, const char* fileName) { EmbRect boundingRect; int stitchCount, minColors, patternColor; int attributeSize = 0; int xCompressedSize = 0; int yCompressedSize = 0; double previousX = 0; double previousY = 0; unsigned char* xValues = 0, *yValues = 0, *attributeValues = 0; EmbStitchList* pointer = 0; double xx = 0.0; double yy = 0.0; int flags = 0; int i = 0; unsigned char* attributeCompressed = 0, *xCompressed = 0, *yCompressed = 0, *decodedColors = 0, *encodedColors = 0; unsigned char prevByte = 0; EmbThreadList* colorPointer = 0; EmbFile* file = 0; if(!pattern) { embLog_error("format-vip.c writeVip(), pattern argument is null\n"); return 0; } if(!fileName) { embLog_error("format-vip.c writeVip(), fileName argument is null\n"); return 0; } stitchCount = embStitchList_count(pattern->stitchList); if(!stitchCount) { embLog_error("format-vip.c writeVip(), pattern contains no stitches\n"); return 0; } /* Check for an END stitch and add one if it is not present */ if(pattern->lastStitch && pattern->lastStitch->stitch.flags != END) { embPattern_addStitchRel(pattern, 0, 0, END, 1); stitchCount++; } file = embFile_open(fileName, "wb"); if(file == 0) { embLog_error("format-vip.c writeVip(), cannot open %s for writing\n", fileName); return 0; } minColors = embThreadList_count(pattern->threadList); decodedColors = (unsigned char*)malloc(minColors << 2); if(!decodedColors) return 0; encodedColors = (unsigned char*)malloc(minColors << 2); if(encodedColors) /* TODO: review this line. It looks clearly wrong. If not, note why. */ { free(decodedColors); decodedColors = 0; return 0; } /* embPattern_correctForMaxStitchLength(pattern, 0x7F, 0x7F); */ patternColor = minColors; if(minColors > 24) minColors = 24; binaryWriteUInt(file, 0x0190FC5D); binaryWriteUInt(file, stitchCount); binaryWriteUInt(file, minColors); boundingRect = embPattern_calcBoundingBox(pattern); binaryWriteShort(file, (short) roundDouble(boundingRect.right * 10.0)); binaryWriteShort(file, (short) -roundDouble(boundingRect.top * 10.0 - 1.0)); binaryWriteShort(file, (short) roundDouble(boundingRect.left * 10.0)); binaryWriteShort(file, (short) -roundDouble(boundingRect.bottom * 10.0 - 1.0)); binaryWriteUInt(file, 0x38 + (minColors << 3)); xValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount)); yValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount)); attributeValues = (unsigned char*)malloc(sizeof(unsigned char)*(stitchCount)); if(xValues && yValues && attributeValues) { pointer = pattern->stitchList; while(pointer) { xx = pointer->stitch.xx; yy = pointer->stitch.yy; flags = pointer->stitch.flags; xValues[i] = vipEncodeByte((xx - previousX) * 10.0); previousX = xx; yValues[i] = vipEncodeByte((yy - previousY) * 10.0); previousY = yy; attributeValues[i] = vipEncodeStitchType(flags); pointer = pointer->next; i++; } attributeCompressed = vipCompressData(attributeValues, stitchCount, &attributeSize); xCompressed = vipCompressData(xValues, stitchCount, &xCompressedSize); yCompressed = vipCompressData(yValues, stitchCount, &yCompressedSize); binaryWriteUInt(file, (unsigned int) (0x38 + (minColors << 3) + attributeSize)); binaryWriteUInt(file, (unsigned int) (0x38 + (minColors << 3) + attributeSize + xCompressedSize)); binaryWriteUInt(file, 0x00000000); binaryWriteUInt(file, 0x00000000); binaryWriteUShort(file, 0x0000); binaryWriteInt(file, minColors << 2); colorPointer = pattern->threadList; for(i = 0; i < minColors; i++) { int byteChunk = i << 2; EmbColor currentColor = colorPointer->thread.color; decodedColors[byteChunk] = currentColor.r; decodedColors[byteChunk + 1] = currentColor.g; decodedColors[byteChunk + 2] = currentColor.b; decodedColors[byteChunk + 3] = 0x01; colorPointer = colorPointer->next; } for(i = 0; i < minColors << 2; ++i) { unsigned char tmpByte = (unsigned char) (decodedColors[i] ^ vipDecodingTable[i]); prevByte = (unsigned char) (tmpByte ^ prevByte); binaryWriteByte(file, prevByte); } for(i = 0; i <= minColors; i++) { binaryWriteInt(file, 1); } binaryWriteUInt(file, 0); /* string length */ binaryWriteShort(file, 0); binaryWriteBytes(file, (char*) attributeCompressed, attributeSize); binaryWriteBytes(file, (char*) xCompressed, xCompressedSize); binaryWriteBytes(file, (char*) yCompressed, yCompressedSize); } if(attributeCompressed) { free(attributeCompressed); attributeCompressed = 0; } if(xCompressed) { free(xCompressed); xCompressed = 0; } if(yCompressed) { free(yCompressed); yCompressed = 0; } if(attributeValues) { free(attributeValues); attributeValues = 0; } if(xValues) { free(xValues); xValues = 0; } if(yValues) { free(yValues); yValues = 0; } if(decodedColors) { free(decodedColors); decodedColors = 0; } if(encodedColors) { free(encodedColors); encodedColors = 0; } embFile_close(file); return 1; }