void ClusterMaker::generateClusters(Storage::Event* event, unsigned int planeNum) { Storage::Plane* plane = event->getPlane(planeNum); if (plane->getNumClusters() > 0) throw "ClusterMaker: clusters already exist for this hit"; for (unsigned int nhit = 0; nhit < plane->getNumHits(); nhit++) { Storage::Hit* hit = plane->getHit(nhit); //std::cout << "addHit: " << nhit << " isclustered: " <<hit->getCluster() << " isHit: " << hit->getIsHit() << std::endl; // If the hit isn't clustered, make a new cluster if (!hit->getCluster()) { Storage::Cluster* cluster = event->newCluster(planeNum); cluster->addHit(hit); } // Add neighbouring clusters to this hit (this is recursive) Storage::Cluster* lastCluster = plane->getCluster(plane->getNumClusters() - 1); assert(lastCluster && "ClusterMaker: hits didn't generate any clusters"); addNeighbours(hit, plane, lastCluster); } // Recursive search has ended, finalize all the cluster information for (unsigned int i = 0; i < plane->getNumClusters(); i++) calculateCluster(plane->getCluster(i)); }
void ClusterMaker::addNeighbours(const Storage::Hit* hit, const Storage::Plane* plane, Storage::Cluster* cluster) { // Go through all hits for (unsigned int nhit = 0; nhit < plane->getNumHits(); nhit++) { Storage::Hit* compare = plane->getHit(nhit); // Continue if this hit is already clustered or if it is the one being considered if (compare->getCluster() || compare == hit) continue; // If a maximum separation has been defined in real coordinates, check now if (_maxSeparation > 0) { const double distX = compare->getPosX() - hit->getPosX(); const double distY = compare->getPosY() - hit->getPosY(); const double dist = sqrt(pow(distX, 2) + pow(distY, 2)); if (dist > _maxSeparation) continue; } else { const int distX = compare->getPixX() - hit->getPixX(); const int distY = compare->getPixY() - hit->getPixY(); if (fabs(distX) > _maxSeparationX || fabs(distY) > _maxSeparationY) continue; } // Add this hit to the cluster we are making cluster->addHit(compare); // Continue adding neigbours of this hit into the cluster addNeighbours(compare, plane, cluster); } }
/** * Refines the grid and updates the shadow storage. */ void PrewaveletGridGenerator::refine(RefinementFunctor* func) { HashRefinement refine; size_t start = this->storage->size(); refine.free_refine(this->storage, func); size_t end = this->storage->size(); // All added gridpoint are between [start,end[ // Check if a gridpoint within the shadow storage // is now part of the actual grid! for (size_t i = start; i < end; i++) { if (shadowstorage->find(storage->get(i)) != shadowstorage->end()) { consolidateShadow(); break; } } // Now add all missing neigbours to the shadowStorage for (size_t i = start; i < end; i++) { GridStorage::index_pointer index = this->storage->get(i); level_t sum = 0; for (size_t d = 0; d < storage->dim(); ++d) { index_t current_index; level_t current_level; index->get(d, current_level, current_index); sum += current_level; } GridStorage::grid_iterator iter(storage); GridStorage::grid_iterator shadowIter(shadowstorage); addNeighbours(*this->storage->get(i), 0, sum, iter, shadowIter); } }
void ZoneManager::spawnMap() { int startX, startY(50); float width = zoneBegin.width(); float heigth = zoneBegin.heigth(); float spareSpaceHorizontal = 1.5; float spareSpaceVertical = 2; int zonePerLine = (screenSize_.height / width) ; int lineInScreen = (screenSize_.width / heigth); int completeLineModifier(0); startX = (screenSize_.width - width*(zonePerLine-1)*spareSpaceHorizontal) / 2; Zone temp; int curId = 1; for (int j(0); j <= lineInScreen; ++j) { for (int i(0); i < zonePerLine - completeLineModifier; ++i) { temp = spawnZone(startX + i*width*spareSpaceHorizontal + completeLineModifier*width*0.75, j*heigth / spareSpaceVertical + startY); temp.setId(curId); addNeighbours(curId, temp, lineInScreen, zonePerLine, i, j, completeLineModifier); zoneDict[curId] = temp; zoneDict[curId].addToLayer(*layer_); zoneList.push_back(&zoneDict[curId]); curId++; } if (completeLineModifier == 0) completeLineModifier = 1; else completeLineModifier = 0; } zoneBegin.setPosition(Vec2(screenSize_.width / 2 - spareSpaceHorizontal * width, screenSize_.height - heigth/1.5)); zoneEnd.setPosition(Vec2(screenSize_.width / 2, screenSize_.height - heigth/1.5)); zoneObstacle.setPosition(Vec2(screenSize_.width / 2 + spareSpaceHorizontal * width, screenSize_.height - heigth/1.5)); zoneList.push_back(&zoneBegin); zoneList.push_back(&zoneEnd); zoneList.push_back(&zoneObstacle); zoneBegin.addToLayer(*layer_); zoneEnd.addToLayer(*layer_); zoneObstacle.addToLayer(*layer_); }
void PrewaveletGridGenerator::addNeighbours(index_type& index, size_t current_dim, level_t target_level, GridStorage::grid_iterator& iter, GridStorage::grid_iterator& shadowIter) { level_t sum = 0; for (size_t d = 0; d < storage->dim(); ++d) { index_t current_index; level_t current_level; iter.get(d, current_level, current_index); sum += current_level; } if (sum == target_level) { GridStorage::index_pointer new_index = new GridStorage::index_type( storage->dim()); if (storage->end(iter.seq()) && shadowstorage->end(shadowIter.seq())) { // Ok, point is neither in storage, nor in shadowstorage ... // check if the border of index and iter touching for (size_t d = 0; d < storage->dim(); ++d) { index_t target_index; level_t target_level; index_t current_index; level_t current_level; iter.get(d, current_level, current_index); index.get(d, target_level, target_index); new_index->set(d, current_level, current_index); // The index cast to int is required to allow a negative index int target_left = static_cast<int>((1.0 / (1 << target_level)) * static_cast<float_t>( static_cast<int>(target_index) - 3)); int target_right = static_cast<int>((1.0 / (1 << target_level)) * static_cast<float_t>( static_cast<int>(target_index) + 3)); int current_left = static_cast<int>((1.0 / (1 << current_index)) * static_cast<float_t>( static_cast<int>(current_level) + 3)); int current_right = static_cast<int>((1.0 / (1 << current_index)) * static_cast<float_t>( static_cast<int>(current_level) + 3)); if (!(current_right > target_left || current_left < target_right)) { return; delete new_index; } } // Yepp, the supports touching each other! Add point to shadow! shadowstorage->insert(*new_index); delete new_index; // Call for parents insertParents(iter, shadowIter); } return; } else if (sum > target_level) { return; } for (size_t d = current_dim; d < storage->dim(); d++) { index_t save_index; level_t save_level; iter.get(d, save_level, save_index); // Save current index iter.leftChild(d); shadowIter.leftChild(d); addNeighbours(index, d, target_level, iter, shadowIter); iter.set(d, save_level, save_index); // reset index shadowIter.set(d, save_level, save_index); // reset index iter.rightChild(d); shadowIter.rightChild(d); addNeighbours(index, d, target_level, iter, shadowIter); iter.set(d, save_level, save_index); // reset index shadowIter.set(d, save_level, save_index); } }