//! Setup Hierarchy object
virtual void SetupHierarchy(Hierarchy& H) const {
TEUCHOS_TEST_FOR_EXCEPTION(!H.GetLevel(0)->IsAvailable("A"), Exceptions::RuntimeError, "No fine level operator");
// Setup Matrix
// TODO: I should certainly undo this somewhere...
RCP<Level> l = H.GetLevel(0);
RCP<Matrix> Op = l->Get<RCP<Matrix> >("A");
Xpetra::UnderlyingLib lib = Op->getRowMap()->lib();
H.setlib(lib);
SetupMatrix(*Op);
SetupExtra(H);
// Setup Hierarchy
H.SetMaxCoarseSize(maxCoarseSize_);
H.SetDefaultVerbLevel(verbosity_);
if (graphOutputLevel_ >= 0)
H.EnableGraphDumping("dep_graph.dot", graphOutputLevel_);
// TODO: coarsestLevelManager
H.Clear();
int levelID = 0;
int lastLevelID = numDesiredLevel_ - 1;
bool isLastLevel = false;
while (!isLastLevel) {
bool r = H.Setup(levelID,
LvlMngr(levelID-1, lastLevelID),
LvlMngr(levelID, lastLevelID),
LvlMngr(levelID+1, lastLevelID));
isLastLevel = r || (levelID == lastLevelID);
levelID++;
}
RCP<Teuchos::FancyOStream> fos = Teuchos::fancyOStream(Teuchos::rcpFromRef(std::cout));
fos->setOutputToRootOnly(0);
H.print(*fos,verbosity_);
// When we reuse hierarchy, it is necessary that we don't
// change the number of levels. We also cannot make requests
// for coarser levels, because we don't construct all the
// data on previous levels. For instance, let's say our first
// run constructed three levels. If we try to do requests during
// next setup for the fourth level, it would need Aggregates
// which we didn't construct for level 3 because we reused P.
// To fix this situation, we change the number of desired levels
// here.
numDesiredLevel_ = levelID;
WriteData<Matrix>(H, matricesToPrint_, "A");
WriteData<Matrix>(H, prolongatorsToPrint_, "P");
WriteData<Matrix>(H, restrictorsToPrint_, "R");
} //SetupHierarchy
int main(int argc, char** argv) {
// Initialize Google's logging library.
google::InitGoogleLogging(argv[0]);
google::ParseCommandLineFlags(&argc, &argv, true);
if (FLAGS_logging) {
FLAGS_logtostderr = 1;
}
if (FLAGS_input.empty()) {
std::cerr << "Input file not specified. Specify via -input.\n";
return 1;
}
// Determine conversion mode.
enum ConvMode { CONV_TEXT, CONV_BINARY, CONV_BITMAP_ID, CONV_BITMAP_COLOR, STRIP };
ConvMode mode = CONV_TEXT;
float hier_level = 0;
std::string dest_filename;
if (FLAGS_text_format) {
mode = CONV_TEXT;
std::cout << "Converting to text.";
} else if (FLAGS_binary_format) {
mode = CONV_BINARY;
std::cout << "Converting to binary format.";
} else if (FLAGS_bitmap_ids >= 0) {
mode = CONV_BITMAP_ID;
hier_level = FLAGS_bitmap_ids;
std::cout << "Converting to id bitmaps for hierarchy level: " << hier_level << "\n";
} else if (FLAGS_bitmap_color >= 0) {
mode = CONV_BITMAP_COLOR;
hier_level = FLAGS_bitmap_color;
std::cout << "Converting to color bitmaps for hierarchy level: "
<< hier_level << "\n";
} else if (!FLAGS_strip.empty()) {
mode = STRIP;
dest_filename = FLAGS_strip;
} else {
std::cout << "Unknown mode specified.\n";
return 1;
}
std::string filename = FLAGS_input;
// Read segmentation file.
// Don't need rasterization when we are stripping file.
const bool valid_rasterization = !FLAGS_strip.empty();
SegmentationReader segment_reader(filename, valid_rasterization);
segment_reader.OpenFileAndReadHeaders();
std::vector<int> segment_headers = segment_reader.GetHeaderFlags();
std::cout << "Segmentation file " << filename << " contains "
<< segment_reader.NumFrames() << " frames.\n";
SegmentationWriter* writer = nullptr;
bool use_vectorization = false;
if (mode == STRIP) {
writer = new SegmentationWriter(dest_filename);
std::vector<int> header_entries;
if (!FLAGS_use_rasterization && segment_headers.size() > 0) {
header_entries.push_back(use_vectorization = segment_headers[0]);
} else {
header_entries.push_back(0);
}
header_entries.push_back(0); // No shape moments.
if (!writer->OpenFile(header_entries)) {
std::cout << "Could not open destination file.\n";
delete writer;
return 1;
}
LOG(INFO) << "Stripping files with " << (use_vectorization ? "vectorization"
: "rasterization");
}
Hierarchy hierarchy;
const int chunk_size = 100; // By default use chunks of 100 frames.
int absolute_level = -1;
// Use absolute level if supplied.
if (hier_level == 0 || hier_level >= 1) {
absolute_level = hier_level;
}
for (int f = 0; f < segment_reader.NumFrames(); ++f) {
segment_reader.SeekToFrame(f);
// Read from file.
SegmentationDesc segmentation;
segment_reader.ReadNextFrame(&segmentation);
if (segmentation.hierarchy_size() > 0) {
hierarchy.Clear();
hierarchy.MergeFrom(segmentation.hierarchy());
// Convert fractional to constant absolute level.
if (absolute_level < 0) {
absolute_level = hier_level * (float)hierarchy.size();
LOG(INFO) << "Selecting level " << absolute_level << " of " << hierarchy.size()
<< std::endl;
}
}
std::string curr_file = FLAGS_output_dir + "/";
if (mode == CONV_TEXT) {
curr_file += base::StringPrintf("frame%05d.pbtxt", f);
} else if (mode == CONV_BINARY) {
curr_file += base::StringPrintf("frame%05d.pb", f);
} else {
curr_file += base::StringPrintf("frame%05d.png", f);
}
if (f % 5 == 0) {
std::cout << "Writing frame " << f << " of "
<< segment_reader.NumFrames() << "\n";
}
int frame_width = segmentation.frame_width();
int frame_height = segmentation.frame_height();
if (mode == CONV_BINARY) {
std::ofstream ofs(curr_file, std::ios_base::out | std::ios_base::binary);
segmentation.SerializeToOstream(&ofs);
} else if (mode == CONV_TEXT) {
std::ofstream ofs(curr_file, std::ios_base::out);
ofs << segmentation.DebugString();
} else if (mode == CONV_BITMAP_ID) {
cv::Mat id_image(frame_height, frame_width, CV_32S);
SegmentationDescToIdImage(absolute_level,
segmentation,
&hierarchy,
&id_image);
// Get 4 channel view via evil casting.
cv::Mat id_image_view(frame_height, frame_width, CV_8UC4, id_image.ptr<uint8_t>(0));
// Discard most significant 8bit (little endian).
vector<cv::Mat> id_channels;
cv::split(id_image_view, id_channels);
cv::Mat frame_buffer(frame_height, frame_width, CV_8UC3);
cv::merge(&id_channels[0], 3, frame_buffer);
cv::imwrite(curr_file, frame_buffer);
} else if (mode == CONV_BITMAP_COLOR) {
cv::Mat frame_buffer(frame_height, frame_width, CV_8UC3);
RenderRegionsRandomColor(absolute_level,
true,
false,
segmentation,
&hierarchy,
&frame_buffer);
cv::imwrite(curr_file, frame_buffer);
} else if (mode == STRIP) {
std::string stripped_data;
StripToEssentials(segmentation,
use_vectorization,
false, // no shape moments.
&stripped_data);
writer->AddSegmentationDataToChunk(stripped_data, f);
if (f > 0 && f % chunk_size == 0) {
writer->WriteChunk();
}
}
}
if (mode == STRIP) {
writer->WriteTermHeaderAndClose();
delete writer;
}
segment_reader.CloseFile();
return 0;
}
