int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Merger m;
m.show();
return app.exec();
}
int STDCALL
WinMain (HINSTANCE hInstance, HINSTANCE hPrev, LPSTR lpCmd, int nShow)
#endif
{
Merger merger;
merger.doMerge ();
/* Create Process */
start ("acqua.exe");
return 0;
}
void MergerEditor::switchSource()
{
bool isBOn = pipelineSelectorB->getToggleState();
bool isAOn = pipelineSelectorA->getToggleState();
pipelineSelectorB->setToggleState(!isBOn, dontSendNotification);
pipelineSelectorA->setToggleState(!isAOn, dontSendNotification);
Merger* processor = (Merger*) getProcessor();
processor->switchIO();
}
void MergerEditor::mouseDown(const MouseEvent& e)
{
if (e.mods.isRightButtonDown())
{
PopupMenu m;
m.addItem(1, "Choose input 2:",false);
Array<GenericProcessor*> availableProcessors = getProcessorGraph()->getListOfProcessors();
for (int i = 0; i < availableProcessors.size(); i++)
{
if (!availableProcessors[i]->isSink() &&
!availableProcessors[i]->isMerger() &&
!availableProcessors[i]->isSplitter() &&
availableProcessors[i]->getDestNode() != getProcessor())
{
String name = String(availableProcessors[i]->getNodeId());
name += " - ";
name += availableProcessors[i]->getName();
m.addItem(i+2, name);
//processorsInList.add(availableProcessors[i]);
}
}
const int result = m.show();
if (result > 1)
{
std::cout << "Selected " << availableProcessors[result-2]->getName() << std::endl;
switchSource(1);
Merger* processor = (Merger*) getProcessor();
processor->setMergerSourceNode(availableProcessors[result-2]);
availableProcessors[result-2]->setDestNode(getProcessor());
getGraphViewer()->updateNodeLocations();
getEditorViewport()->makeEditorVisible(this, false, true);
}
}
}
int main(int argc, char **argv)
{
Merger::Buffers mem;
Merger m (mem);
WorldObject *o = new DisplayObject();
Merger::Buffer* wr = mem.getWriteAccess();
wr->insert(std::make_pair<ID, WorldObject*>(42, o));
mem.releaseWriteAccess(&wr);
mem.swap();
m.update("<physics><object_id>42</object_id><position><x>1</x><y>2</y><z>3</z></position><orientation><w>4</w><x>5</x><y>6</y><z>7</z></orientation></physics><physics><");
return (0);
}
void ProcessorGraph::connectProcessors(GenericProcessor* source, GenericProcessor* dest)
{
if (source == nullptr || dest == nullptr)
return;
std::cout << " Connecting " << source->getName() << " " << source->getNodeId(); //" channel ";
std::cout << " to " << dest->getName() << " " << dest->getNodeId() << std::endl;
bool connectContinuous = true;
bool connectEvents = true;
if (source->getDestNode() != nullptr)
{
if (source->getDestNode()->isMerger())
{
Merger* merger = (Merger*) source->getDestNode();
connectContinuous = merger->sendContinuousForSource(source);
connectEvents = merger->sendEventsForSource(source);
}
}
// 1. connect continuous channels
if (connectContinuous)
{
for (int chan = 0; chan < source->getNumOutputs(); chan++)
{
//std::cout << chan << " ";
addConnection(source->getNodeId(), // sourceNodeID
chan, // sourceNodeChannelIndex
dest->getNodeId(), // destNodeID
dest->getNextChannel(true)); // destNodeChannelIndex
}
}
// 2. connect event channel
if (connectEvents)
{
addConnection(source->getNodeId(), // sourceNodeID
midiChannelIndex, // sourceNodeChannelIndex
dest->getNodeId(), // destNodeID
midiChannelIndex); // destNodeChannelIndex
}
}
int MergerEditor::getPathForEditor(GenericEditor* editor)
{
Merger* processor = (Merger*) getProcessor();
for (int pathNum = 0; pathNum < 2; pathNum++)
{
switchSource(pathNum);
if (processor->getSourceNode() != nullptr)
{
if (processor->getEditor() == editor)
return pathNum;
}
}
return -1;
}
void MergerEditor::switchSource(int source)
{
if (source == 0)
{
pipelineSelectorA->setToggleState(true, dontSendNotification);
pipelineSelectorB->setToggleState(false, dontSendNotification);
Merger* processor = (Merger*) getProcessor();
processor->switchIO(0);
}
else if (source == 1)
{
pipelineSelectorB->setToggleState(true, dontSendNotification);
pipelineSelectorA->setToggleState(false, dontSendNotification);
Merger* processor = (Merger*) getProcessor();
processor->switchIO(1);
}
}
void MergerEditor::buttonEvent(Button* button)
{
if (button == pipelineSelectorA)
{
pipelineSelectorA->setToggleState(true,false);
pipelineSelectorB->setToggleState(false,false);
Merger* processor = (Merger*) getProcessor();
processor->switchIO(0);
}
else if (button == pipelineSelectorB)
{
pipelineSelectorB->setToggleState(true,false);
pipelineSelectorA->setToggleState(false,false);
Merger* processor = (Merger*) getProcessor();
processor->switchIO(1);
}
}
TEST(Merge, Bad) {
const char *kInvalidInputs[] = {
"",
"x",
"3\nx",
"2\n3",
"2\n2",
"2\n2\nA\n",
"2\n2\nA\nB\nC\n",
"0\n0\n",
"1\n1\nA\nDONE 0",
"1\n1\nA\nSTARTED 1",
};
Merger M;
for (auto S : kInvalidInputs) {
// fprintf(stderr, "TESTING:\n%s\n", S);
EXPECT_FALSE(M.Parse(S, false));
}
}
Array<GenericEditor*> MergerEditor::getConnectedEditors()
{
Array<GenericEditor*> editors;
Merger* processor = (Merger*) getProcessor();
for (int pathNum = 0; pathNum < 2; pathNum++)
{
processor->switchIO();
if (processor->getSourceNode() != nullptr)
editors.add(processor->getSourceNode()->getEditor());
else
editors.add(nullptr);
}
return editors;
}
void MergerEditor::buttonEvent(Button* button)
{
if (button == pipelineSelectorA)
{
pipelineSelectorA->setToggleState(true, dontSendNotification);
pipelineSelectorB->setToggleState(false, dontSendNotification);
Merger* processor = (Merger*) getProcessor();
processor->switchIO(0);
}
else if (button == pipelineSelectorB)
{
pipelineSelectorB->setToggleState(true, dontSendNotification);
pipelineSelectorA->setToggleState(false, dontSendNotification);
Merger* processor = (Merger*) getProcessor();
processor->switchIO(1);
}
getEditorViewport()->makeEditorVisible(this, false);
}
static void Merge(const std::string &Input,
const std::vector<std::string> Result,
size_t NumNewFeatures) {
Merger M;
std::vector<std::string> NewFiles;
EXPECT_TRUE(M.Parse(Input, true));
std::stringstream SS;
M.PrintSummary(SS);
EXPECT_EQ(NumNewFeatures, M.Merge(&NewFiles));
EXPECT_EQ(M.AllFeatures(), M.ParseSummary(SS));
EQ(NewFiles, Result);
}
void UBExportFullPDF::persistsDocument(UBDocumentProxy* pDocumentProxy, const QString& filename)
{
QFile file(filename);
if (file.exists()) file.remove();
QString overlayName = filename;
overlayName.replace(".pdf", "_overlay.pdf");
QFile previousOverlay(overlayName);
if (previousOverlay.exists())
previousOverlay.remove();
mHasPDFBackgrounds = false;
saveOverlayPdf(pDocumentProxy, overlayName);
if (!mHasPDFBackgrounds)
{
QFile f(overlayName);
f.rename(filename);
}
else
{
Merger merger;
try
{
merger.addOverlayDocument(QFile::encodeName(overlayName).constData());
MergeDescription mergeInfo;
int existingPageCount = pDocumentProxy->pageCount();
for(int pageIndex = 0 ; pageIndex < existingPageCount; pageIndex++)
{
UBGraphicsScene* scene = UBPersistenceManager::persistenceManager()->loadDocumentScene(pDocumentProxy, pageIndex);
UBGraphicsPDFItem *pdfItem = qgraphicsitem_cast<UBGraphicsPDFItem*>(scene->backgroundObject());
QSize pageSize = scene->nominalSize();
if (pdfItem)
{
QString pdfName = UBPersistenceManager::objectDirectory + "/" + pdfItem->fileUuid().toString() + ".pdf";
QString backgroundPath = pDocumentProxy->persistencePath() + "/" + pdfName;
qDebug() << "scene->itemsBoundingRect()" << scene->itemsBoundingRect();
qDebug() << "pdfItem->boundingRect()" << pdfItem->boundingRect();
qDebug() << "pdfItem->sceneBoundingRect()" << pdfItem->sceneBoundingRect();
MergePageDescription pageDescription(pageSize.width() * mScaleFactor,
pageSize.height() * mScaleFactor,
pdfItem->pageNumber(),
QFile::encodeName(backgroundPath).constData(),
TransformationDescription(),
pageIndex + 1,
TransformationDescription(),
false, false);
mergeInfo.push_back(pageDescription);
merger.addBaseDocument(QFile::encodeName(backgroundPath).constData());
}
else
{
MergePageDescription pageDescription(pageSize.width() * mScaleFactor,
pageSize.height() * mScaleFactor,
0,
"",
TransformationDescription(),
pageIndex + 1,
TransformationDescription(),
false, true);
mergeInfo.push_back(pageDescription);
}
}
merger.merge(QFile::encodeName(overlayName).constData(), mergeInfo);
merger.saveMergedDocumentsAs(QFile::encodeName(filename).constData());
}
catch(Exception e)
{
qDebug() << "PdfMerger failed to merge documents to " << filename << " - Exception : " << e.what();
// default to raster export
UBExportPDF::persistsDocument(pDocumentProxy, filename);
}
if (!UBApplication::app()->isVerbose())
{
QFile::remove(overlayName);
}
}
}
TEST(Merge, Good) {
Merger M;
EXPECT_TRUE(M.Parse("1\n0\nAA\n", false));
EXPECT_EQ(M.Files.size(), 1U);
EXPECT_EQ(M.NumFilesInFirstCorpus, 0U);
EXPECT_EQ(M.Files[0].Name, "AA");
EXPECT_TRUE(M.LastFailure.empty());
EXPECT_EQ(M.FirstNotProcessedFile, 0U);
EXPECT_TRUE(M.Parse("2\n1\nAA\nBB\nSTARTED 0 42\n", false));
EXPECT_EQ(M.Files.size(), 2U);
EXPECT_EQ(M.NumFilesInFirstCorpus, 1U);
EXPECT_EQ(M.Files[0].Name, "AA");
EXPECT_EQ(M.Files[1].Name, "BB");
EXPECT_EQ(M.LastFailure, "AA");
EXPECT_EQ(M.FirstNotProcessedFile, 1U);
EXPECT_TRUE(M.Parse("3\n1\nAA\nBB\nC\n"
"STARTED 0 1000\n"
"DONE 0 1 2 3\n"
"STARTED 1 1001\n"
"DONE 1 4 5 6 \n"
"STARTED 2 1002\n"
"", true));
EXPECT_EQ(M.Files.size(), 3U);
EXPECT_EQ(M.NumFilesInFirstCorpus, 1U);
EXPECT_EQ(M.Files[0].Name, "AA");
EXPECT_EQ(M.Files[0].Size, 1000U);
EXPECT_EQ(M.Files[1].Name, "BB");
EXPECT_EQ(M.Files[1].Size, 1001U);
EXPECT_EQ(M.Files[2].Name, "C");
EXPECT_EQ(M.Files[2].Size, 1002U);
EXPECT_EQ(M.LastFailure, "C");
EXPECT_EQ(M.FirstNotProcessedFile, 3U);
EQ(M.Files[0].Features, {1, 2, 3});
EQ(M.Files[1].Features, {4, 5, 6});
std::vector<std::string> NewFiles;
EXPECT_TRUE(M.Parse("3\n2\nAA\nBB\nC\n"
"STARTED 0 1000\nDONE 0 1 2 3\n"
"STARTED 1 1001\nDONE 1 4 5 6 \n"
"STARTED 2 1002\nDONE 2 6 1 3 \n"
"", true));
EXPECT_EQ(M.Files.size(), 3U);
EXPECT_EQ(M.NumFilesInFirstCorpus, 2U);
EXPECT_TRUE(M.LastFailure.empty());
EXPECT_EQ(M.FirstNotProcessedFile, 3U);
EQ(M.Files[0].Features, {1, 2, 3});
EQ(M.Files[1].Features, {4, 5, 6});
EQ(M.Files[2].Features, {1, 3, 6});
EXPECT_EQ(0U, M.Merge(&NewFiles));
EQ(NewFiles, {});
EXPECT_TRUE(M.Parse("3\n1\nA\nB\nC\n"
"STARTED 0 1000\nDONE 0 1 2 3\n"
"STARTED 1 1001\nDONE 1 4 5 6 \n"
"STARTED 2 1002\nDONE 2 6 1 3\n"
"", true));
EQ(M.Files[0].Features, {1, 2, 3});
EQ(M.Files[1].Features, {4, 5, 6});
EQ(M.Files[2].Features, {1, 3, 6});
EXPECT_EQ(3U, M.Merge(&NewFiles));
EQ(NewFiles, {"B"});
// Same as the above, but with InitialFeatures.
EXPECT_TRUE(M.Parse("2\n0\nB\nC\n"
"STARTED 0 1001\nDONE 0 4 5 6 \n"
"STARTED 1 1002\nDONE 1 6 1 3\n"
"", true));
EQ(M.Files[0].Features, {4, 5, 6});
EQ(M.Files[1].Features, {1, 3, 6});
EXPECT_EQ(3U, M.Merge({1, 2, 3}, &NewFiles));
EQ(NewFiles, {"B"});
}
void Gatherer::gather()
{
zmq::message_t start_msg;
zmq::message_t start_msg2;
input_socket.recv(&start_msg);
size_t* input_buffer = static_cast<size_t*>(start_msg.data());
size_t num_jobs = *input_buffer;
input_socket.recv(&start_msg2);
input_buffer = static_cast<size_t*>(start_msg2.data());
size_t n = *input_buffer;
struct timeval tstart, tend;
gettimeofday (&tstart, NULL);
//std::cout << "Received problem info: " << num_jobs << " " << n << std::endl;
Real* parallel_assembly_times = new Real[num_jobs];
Real total_assembly_time(0);
Merger* merger = new Merger(n, num_jobs);
for(size_t i(0); i < num_jobs; ++i)
{
zmq::message_t msg;
input_socket.recv(&msg);
Byte* input_buffer = static_cast<Byte*>(msg.data());
JobResult job_result;
job_result.unpack(input_buffer);
merger->merge_job_result(job_result);
parallel_assembly_times[i] = job_result.get_assembly_time();
}
zmq::message_t kill_msg(5);
memcpy(kill_msg.data(), "KILL", 5);
control_socket.send(kill_msg);
//std::cout << "Published kill signal!" << std::endl;
const Real* matrix_ptr = merger->get_matrix_ptr();
const Real* rhs_ptr = merger->get_rhs_ptr();
gettimeofday (&tend, NULL);
total_assembly_time = get_time_difference(tstart, tend);
const Real* x_ptr(NULL);
Solution* solution(NULL);
if(solve)
{
Solver solver(matrix_ptr, rhs_ptr, n);
delete merger;
Solution* solution = solver.get_solution_alloc();
x_ptr = solution->get_x_ptr();
}
else
{
Real* solution = new Real[n];
for(size_t i(0); i < n; ++i)
{
solution[i] = 0.0;
}
x_ptr = solution;
}
size_t total_assembly_time_size = sizeof(total_assembly_time);
size_t parallel_assembly_time_size = total_assembly_time_size*num_jobs;
size_t solution_size = n*sizeof(Real);
zmq::message_t parallel_assembly_time_msg(parallel_assembly_time_size);
zmq::message_t total_assembly_time_msg(total_assembly_time_size);
zmq::message_t solution_msg(solution_size);
memcpy(parallel_assembly_time_msg.data(), parallel_assembly_times, parallel_assembly_time_size);
memcpy(total_assembly_time_msg.data(), &total_assembly_time, total_assembly_time_size);
memcpy(solution_msg.data(), x_ptr, solution_size);
delete[] parallel_assembly_times;
control_socket.send(parallel_assembly_time_msg, ZMQ_SNDMORE);
control_socket.send(total_assembly_time_msg, ZMQ_SNDMORE);
control_socket.send(solution_msg);
//std::cout << "Published solution!" << std::endl;
if(solve)
{
delete solution;
}
else
{
delete[] x_ptr;
}
}
