std::vector<double> CaptureManager::GetDeformation(int c, float &avgDef)
{
std::vector<CvPoint> traj = GetTrajectory(c);
std::vector<double> areas = GetAreas(c,avgDef);
std::vector<double> defs(frameCount-1, 0.0);
float totalDef = 0;
int goodSteps = 0;
CvSeq *h_next;
ImagePlus *img_ = new ImagePlus(img);
IplImage *gray = cvCreateImage(cvGetSize(img.orig), IPL_DEPTH_8U, 1);
IplImage *edge = cvCreateImage(cvGetSize(img.orig), IPL_DEPTH_8U, 1);
for (int i=0; i<frameCount-1; i++)
{
if (!(MyPoint(-1,-1)==traj[i] || MyPoint(-1,-1)==traj[i+1]))
{
wxPoint *ps = ContourToPointArray(Access(i,0,false, true)->contourArray[c], MyPoint(traj[i+1])-MyPoint(traj[i]).ToWxPoint());
img_->RemoveAllContours();
img_->AddContour(ps,Access(i,0,false, true)->contourArray[c]->total);
delete[] ps;
CvSeq *seq = Access(i+1,0,false, true)->contourArray[c];
CvSeq *oseq = img_->contourArray[0];
//Draw both contours on the temporary image
cvZero(img_->orig);
h_next = seq->h_next; seq->h_next = NULL;
cvDrawContours(img_->orig, seq, CV_RGB(255,255,255), CV_RGB(0,0,0), 1, CV_FILLED, CV_AA, cvPoint(0,0));
seq->h_next = h_next;
cvDrawContours(img_->orig, oseq, CV_RGB(255,255,200), CV_RGB(0,0,0), 1, CV_FILLED, CV_AA, cvPoint(0,0));
//detect contours on the drawn image:
FindContoursPlugin::ProcessImage_static(img_,gray,edge,150,50,3,1);
float unionArea = 0;
for (int j=0; j<img_->contourArray.size(); j++)
{
unionArea += fabs(cvContourArea(img_->contourArray[j]));
}
goodSteps++;
totalDef += (defs[i] = 2*unionArea - areas[i] - areas[i+1]);
}
}
cvReleaseImage(&gray);
cvReleaseImage(&edge);
delete img_;
avgDef = (goodSteps ? totalDef/goodSteps : 0);
return defs;
}
std::vector<double> CaptureManager::GetAreaDiff(int c, float &avgDiff)
{
std::vector<double> a = GetAreas(c,avgDiff);
std::vector<double> diff(frameCount-1, 0.0);
float totalDiff = 0;
int goodSteps = 0;
for (int i=0; i<frameCount-1; i++)
{
if (book[i*offset]->contourArray.size() > c)
{
goodSteps++;
totalDiff += (diff[i] = a[i+1]-a[i]);
}
}
avgDiff = (goodSteps ? totalDiff/goodSteps : 0);
return diff;
}
bool CaptureManager::SaveAreaData(const char* file)
{
FILE *fp;
if(!SaveData_setup(file,fp)) return false;
int numContours=book[0]->contourArray.size();
fprintf(fp, "#width: %d, height: %d, frameCount: %d, fps: %d\n", size.width, size.height, frameCount, numContours, fps);
fprintf(fp, "#cellCount: %d\n", numContours);
for (int c=0; c<numContours; c++)
{
CvSeq *oseq = book[0]->contourArray[c];
int np = oseq->total;
float avgArea;
std::vector<double> areas = GetAreas(c, avgArea);
fprintf(fp, "#Cell: %d, pointCount: %d, avgArea: %f\n", c+1, np, avgArea);
for (int i=0; i<areas.size(); i++)
{
fprintf(fp, "%f\n", areas[i]);
}
}
fclose(fp);
return true;
}
bool MergeAreasGenerator::Import(const TypeConfigRef& typeConfig,
const ImportParameter& parameter,
Progress& progress)
{
TypeInfoSet mergeTypes;
FileScanner scanner;
FileWriter writer;
uint32_t areasWritten=0;
for (const auto& type : typeConfig->GetTypes()) {
if (type->CanBeArea() &&
type->GetMergeAreas()) {
mergeTypes.Set(type);
}
}
std::unordered_set<Id> nodeUseMap;
try {
scanner.Open(AppendFileToDir(parameter.GetDestinationDirectory(),
MergeAreaDataGenerator::AREAS_TMP),
FileScanner::Sequential,
parameter.GetRawWayDataMemoryMaped());
if (!ScanAreaNodeIds(progress,
*typeConfig,
scanner,
mergeTypes,
nodeUseMap)) {
return false;
}
uint32_t nodeCount=nodeUseMap.size();
progress.Info("Found "+NumberToString(nodeCount)+" nodes as possible connection points for areas");
/* ------ */
writer.Open(AppendFileToDir(parameter.GetDestinationDirectory(),
AREAS2_TMP));
writer.Write(areasWritten);
while (true) {
TypeInfoSet loadedTypes;
std::vector<AreaMergeData> mergeJob(typeConfig->GetTypeCount());
//
// Load type data
//
progress.SetAction("Collecting area data by type");
if (!GetAreas(parameter,
progress,
*typeConfig,
mergeTypes,
loadedTypes,
nodeUseMap,
scanner,
writer,
mergeJob,
areasWritten)) {
return false;
}
// Merge
progress.SetAction("Merging areas");
for (const auto& type : loadedTypes) {
if (!mergeJob[type->GetIndex()].areas.empty()) {
progress.Info("Merging areas of type "+type->GetName());
MergeAreas(progress,
nodeUseMap,
mergeJob[type->GetIndex()]);
progress.Info("Reduced areas of '"+type->GetName()+"' from "+NumberToString(mergeJob[type->GetIndex()].areaCount)+" to "+NumberToString(mergeJob[type->GetIndex()].areaCount-mergeJob[type->GetIndex()].mergedAway.size()));
mergeJob[type->GetIndex()].areas.clear();
}
}
// Store back merge result
if (!loadedTypes.Empty()) {
if (!WriteMergeResult(progress,
*typeConfig,
scanner,
writer,
loadedTypes,
mergeJob,
areasWritten)) {
return false;
}
mergeTypes.Remove(loadedTypes);
}
if (mergeTypes.Empty()) {
break;
}
}
scanner.Close();
writer.GotoBegin();
writer.Write(areasWritten);
writer.Close();
}
catch (IOException& e) {
progress.Error(e.GetDescription());
scanner.CloseFailsafe();
writer.CloseFailsafe();
return false;
}
return true;
}
bool OptimizeAreasLowZoomGenerator::HandleAreas(const ImportParameter& parameter,
Progress& progress,
const TypeConfig& typeConfig,
FileWriter& writer,
const TypeInfoSet& types,
std::list<TypeData>& typesData)
{
FileScanner scanner;
// Everything smaller than 2mm should get dropped. Width, height and DPI come from the Nexus 4
double dpi=320.0;
double pixel=2.0/* mm */ * dpi / 25.4 /* inch */;
progress.Info("Minimum visible size in pixel: "+NumberToString((unsigned long)pixel));
try {
scanner.Open(AppendFileToDir(parameter.GetDestinationDirectory(),
AreaDataFile::AREAS_DAT),
FileScanner::Sequential,
parameter.GetWayDataMemoryMaped());
TypeInfoSet typesToProcess(types);
std::vector<std::list<AreaRef> > allAreas(typeConfig.GetTypeCount());
while (true) {
//
// Load type data
//
TypeInfoSet loadedTypes;
if (!GetAreas(typeConfig,
parameter,
progress,
scanner,
typesToProcess,
allAreas,
loadedTypes)) {
return false;
}
typesToProcess.Remove(loadedTypes);
for (const auto& type : loadedTypes) {
progress.SetAction("Optimizing type "+ type->GetName());
for (uint32_t level=parameter.GetOptimizationMinMag();
level<=parameter.GetOptimizationMaxMag();
level++) {
Magnification magnification; // Magnification, we optimize for
std::list<AreaRef> optimizedAreas;
magnification.SetLevel(level);
OptimizeAreas(allAreas[type->GetIndex()],
optimizedAreas,
1280,768,
dpi,
pixel,
magnification,
parameter.GetOptimizationWayMethod());
if (optimizedAreas.empty()) {
progress.Debug("Empty optimization result for level "+NumberToString(level)+", no index generated");
TypeData typeData;
typeData.type=type;
typeData.optLevel=level;
typesData.push_back(typeData);
continue;
}
progress.Info("Optimized from "+NumberToString(allAreas[type->GetIndex()].size())+" to "+NumberToString(optimizedAreas.size())+" areas");
/*
size_t optAreas=optimizedAreas.size();
size_t optRoles=0;
size_t optNodes=0;
for (std::list<AreaRef>::const_iterator a=optimizedAreas.begin();
a!=optimizedAreas.end();
++a) {
AreaRef area=*a;
optRoles+=area->rings.size();
for (size_t r=0; r<area->rings.size(); r++) {
optNodes+=area->rings[r].nodes.size();
}
}*/
/*
std::cout << "Areas: " << origAreas << " => " << optAreas << std::endl;
std::cout << "Roles: " << origRoles << " => " << optRoles << std::endl;
std::cout << "Nodes: " << origNodes << " => " << optNodes << std::endl;*/
TypeData typeData;
typeData.type=type;
typeData.optLevel=level;
GetAreaIndexLevel(parameter,
optimizedAreas,
typeData);
//std::cout << "Resulting index level: " << typeData.indexLevel << ", " << typeData.indexCells << ", " << typeData.indexEntries << std::endl;
FileOffsetFileOffsetMap offsets;
WriteAreas(typeConfig,
writer,
optimizedAreas,
offsets);
if (!WriteAreaBitmap(progress,
writer,
optimizedAreas,
offsets,
typeData)) {
return false;
}
typesData.push_back(typeData);
}
allAreas[type->GetIndex()].clear();
}
if (typesToProcess.Empty()) {
break;
}
}
scanner.Close();
}
catch (IOException& e) {
progress.Error(e.GetDescription());
return false;
}
return true;
}
