HammingLoss::HammingLoss(
const Crag& crag,
const BestEffort& bestEffort,
int balance) :
Loss(crag),
_balance((balance == 2 && optionBalanceHammingLoss) || (balance == 1)) {
constant = 0;
for (Crag::CragNode n : crag.nodes())
if (isBestEffort(n, crag, bestEffort)) {
if (_balance)
UTIL_ASSERT(crag.isLeafNode(n));;
node[n] = -1;
constant++;
} else {
if (!_balance || crag.isLeafNode(n))
node[n] = 1;
}
for (Crag::CragEdge e : crag.edges())
if (isBestEffort(e, crag, bestEffort)) {
if (_balance)
UTIL_ASSERT(crag.isLeafEdge(e));;
edge[e] = -1;
constant++;
} else {
if (!_balance || crag.isLeafEdge(e))
edge[e] = 1;
}
if (_balance)
propagateLeafLoss(crag);
}
void create_crag() {
// useful for later:
//
//boost::filesystem::path dataDir = dir_of(__FILE__);
//boost::filesystem::path graphfile = dataDir/"star.dat";
Crag crag;
// add 100 nodes
for (int i = 0; i < 100; i++)
crag.addNode();
// create chains of 10 nodes
for (int i = 0; i < 100; i += 10) {
for (int j = i+1; j < i + 10; j++) {
Crag::Node u = crag.nodeFromId(j-1);
Crag::Node v = crag.nodeFromId(j);
crag.addSubsetArc(u, v);
}
}
// check levels of nodes
for (int i = 0; i < 100; i++) {
Crag::Node n = crag.nodeFromId(i);
BOOST_CHECK_EQUAL(crag.getLevel(n), i%10);
if (i%10 == 0)
BOOST_CHECK(crag.isLeafNode(n));
else
BOOST_CHECK(!crag.isLeafNode(n));
if (i%10 == 9)
BOOST_CHECK(crag.isRootNode(n));
else
BOOST_CHECK(!crag.isRootNode(n));
}
}
bool
HammingLoss::isBestEffort(Crag::CragNode n, const Crag& crag, const BestEffort& bestEffort) {
if (!_balance)
return bestEffort.selected(n);
// if balanced, non-leaf nodes are not considered part of best-effort
if (!crag.isLeafNode(n))
return false;
// is any of the parents best-effort?
while (true) {
if (bestEffort.selected(n))
return true;
if (crag.isRootNode(n))
return false;
n = (*crag.outArcs(n).begin()).target();
}
}
std::set<Crag::Node>
collectLeafNodes(const Crag& crag, Crag::Node n) {
std::set<Crag::Node> leafNodes;
if (crag.isLeafNode(n)) {
leafNodes.insert(n);
} else {
for (Crag::SubsetInArcIt e(crag, crag.toSubset(n)); e != lemon::INVALID; ++e) {
Crag::Node child = crag.toRag(crag.getSubsetGraph().source(e));
std::set<Crag::Node> leafs = collectLeafNodes(crag, child);
for (Crag::Node l : leafs)
leafNodes.insert(l);
}
}
return leafNodes;
}
void
PlanarAdjacencyAnnotator::annotate(Crag& crag) {
if (optionCragType.as<std::string>() == "empty")
return;
UTIL_TIME_METHOD;
util::box<float, 3> cragBB = crag.getBoundingBox();
util::point<float, 3> resolution;
for (Crag::NodeIt n(crag); n != lemon::INVALID; ++n) {
if (!crag.isLeafNode(n))
continue;
resolution = crag.getVolume(n).getResolution();
break;
}
// no nodes?
if (resolution.isZero())
return;
// create a vigra multi-array large enough to hold all volumes
vigra::MultiArray<3, int> ids(
vigra::Shape3(
cragBB.width() /resolution.x(),
cragBB.height()/resolution.y(),
cragBB.depth() /resolution.z()),
std::numeric_limits<int>::max());
for (Crag::NodeIt n(crag); n != lemon::INVALID; ++n) {
if (!crag.isLeafNode(n))
continue;
const util::point<float, 3>& volumeOffset = crag.getVolume(n).getOffset();
const util::box<unsigned int, 3>& volumeDiscreteBB = crag.getVolume(n).getDiscreteBoundingBox();
util::point<unsigned int, 3> begin = (volumeOffset - cragBB.min())/resolution;
util::point<unsigned int, 3> end = begin +
util::point<unsigned int, 3>(
volumeDiscreteBB.width(),
volumeDiscreteBB.height(),
volumeDiscreteBB.depth());
vigra::combineTwoMultiArrays(
crag.getVolume(n).data(),
ids.subarray(
vigra::Shape3(
begin.x(),
begin.y(),
begin.z()),
vigra::Shape3(
end.x(),
end.y(),
end.z())),
ids.subarray(
vigra::Shape3(
begin.x(),
begin.y(),
begin.z()),
vigra::Shape3(
end.x(),
end.y(),
end.z())),
vigra::functor::ifThenElse(
vigra::functor::Arg1() == vigra::functor::Param(1),
vigra::functor::Param(crag.id(n)),
vigra::functor::Arg2()
));
}
//vigra::exportImage(
//ids.bind<2>(0),
//vigra::ImageExportInfo("debug/ids.tif"));
typedef vigra::GridGraph<3> GridGraphType;
typedef vigra::AdjacencyListGraph RagType;
GridGraphType grid(
ids.shape(),
_neighborhood == Direct ? vigra::DirectNeighborhood : vigra::IndirectNeighborhood);
RagType rag;
RagType::EdgeMap<std::vector<GridGraphType::Edge>> affiliatedEdges;
vigra::makeRegionAdjacencyGraph(
grid,
ids,
rag,
affiliatedEdges,
std::numeric_limits<int>::max());
unsigned int numAdded = 0;
crag.setGridGraph(grid);
for (RagType::EdgeIt e(rag); e != lemon::INVALID; ++e) {
int u = rag.id(rag.u(*e));
int v = rag.id(rag.v(*e));
Crag::Edge newEdge = crag.addAdjacencyEdge(
crag.nodeFromId(u),
crag.nodeFromId(v));
crag.setAffiliatedEdges(
newEdge,
affiliatedEdges[*e]);
numAdded++;
LOG_ALL(planaradjacencyannotatorlog)
<< "adding leaf node adjacency between "
<< u << " and " << v << std::endl;
}
LOG_USER(planaradjacencyannotatorlog)
<< "added " << numAdded << " leaf node adjacency edges"
<< std::endl;
if (optionCragType.as<std::string>() == "full")
propagateLeafAdjacencies(crag);
}
void
SolutionImageWriter::write(
const Crag& crag,
const CragVolumes& volumes,
const CragSolution& solution,
const std::string& basename,
bool boundary) {
LOG_DEBUG(solutionimagewriterlog) << "storing solution in " << basename << std::endl;
if (_volumesBB.isZero())
_volumesBB = volumes.getBoundingBox();
LOG_DEBUG(solutionimagewriterlog) << "using bounding box of " << _volumesBB << std::endl;
util::point<float, 3> resolution;
for (Crag::CragNode n : crag.nodes()) {
if (!crag.isLeafNode(n))
continue;
resolution = volumes[n]->getResolution();
break;
}
LOG_DEBUG(solutionimagewriterlog) << "using resolution of " << resolution << std::endl;
// create a vigra multi-array large enough to hold all volumes
vigra::MultiArray<3, float> components(
vigra::Shape3(
_volumesBB.width() /resolution.x(),
_volumesBB.height()/resolution.y(),
_volumesBB.depth() /resolution.z()),
std::numeric_limits<int>::max());
// background for areas without candidates
if (boundary)
components = 0.25;
else
components = 0;
for (Crag::CragNode n : crag.nodes()) {
LOG_ALL(solutionimagewriterlog) << "drawing node " << crag.id(n) << std::endl;
// draw only selected nodes
if (!solution.selected(n))
continue;
const util::point<float, 3>& volumeOffset = volumes[n]->getOffset();
const util::box<unsigned int, 3>& volumeDiscreteBB = volumes[n]->getDiscreteBoundingBox();
util::point<unsigned int, 3> begin = (volumeOffset - _volumesBB.min())/resolution;
util::point<unsigned int, 3> end = begin +
util::point<unsigned int, 3>(
volumeDiscreteBB.width(),
volumeDiscreteBB.height(),
volumeDiscreteBB.depth());
LOG_ALL(solutionimagewriterlog) << "\toffset : " << volumeOffset << std::endl;
LOG_ALL(solutionimagewriterlog) << "\tdiscrete bb : " << volumeDiscreteBB << std::endl;
LOG_ALL(solutionimagewriterlog) << "\ttarget area : " << begin << " -- " << end << std::endl;
// fill id of connected component
vigra::combineTwoMultiArrays(
volumes[n]->data(),
components.subarray(TinyVector3UInt(&begin[0]),TinyVector3UInt(&end[0])),
components.subarray(TinyVector3UInt(&begin[0]),TinyVector3UInt(&end[0])),
vigra::functor::ifThenElse(
vigra::functor::Arg1() == vigra::functor::Param(1),
vigra::functor::Param(solution.label(n)),
vigra::functor::Arg2()
));
}
if (boundary) {
// gray boundary for all leaf nodes
for (Crag::CragNode n : crag.nodes())
if (crag.isLeafNode(n))
drawBoundary(volumes, n, components, 0.5);
// black boundary for all selected nodes
for (Crag::CragNode n : crag.nodes())
if (solution.selected(n))
drawBoundary(volumes, n, components, 0);
}
if (components.shape(2) > 1) {
boost::filesystem::create_directory(basename);
for (unsigned int z = 0; z < components.shape(2); z++) {
std::stringstream ss;
ss << std::setw(4) << std::setfill('0') << z;
vigra::exportImage(
components.bind<2>(z),
vigra::ImageExportInfo((basename + "/" + ss.str() + ".tif").c_str()));
}
} else {
vigra::exportImage(
components.bind<2>(0),
vigra::ImageExportInfo((basename + ".tif").c_str()));
}
}
