core::RigidBody setup_as_rigid_body(Hierarchy h) {
IMP_USAGE_CHECK(h.get_is_valid(true),
"Invalid hierarchy passed to setup_as_rigid_body");
IMP_WARN("create_rigid_body should be used instead of setup_as_rigid_body"
<< " as the former allows one to get volumes correct at coarser"
<< " levels of detail.");
core::RigidBody rbd = core::RigidBody::setup_particle(h, get_leaves(h));
rbd.set_coordinates_are_optimized(true);
kernel::ParticlesTemp internal = core::get_internal(h);
for (unsigned int i = 0; i < internal.size(); ++i) {
if (internal[i] != h) {
core::RigidMembers leaves(get_leaves(Hierarchy(internal[i])));
if (!leaves.empty()) {
algebra::ReferenceFrame3D rf = core::get_initial_reference_frame(
get_as<kernel::ParticlesTemp>(leaves));
core::RigidBody::setup_particle(internal[i], rf);
}
}
}
IMP_INTERNAL_CHECK(h.get_is_valid(true), "Invalid hierarchy produced");
return rbd;
}
// react to keys
void keyboard(unsigned char k, int x, int y)
{
switch(k)
{
case 27: {
hier.destroy();
subRefCP(scene);
delete all;
Profiler::the().dump(SLOG);
exit(0);
}
}
}
IMP::core::RigidBody create_compatible_rigid_body(Hierarchy h,
Hierarchy reference) {
ParticlesTemp hl= get_leaves(h);
ParticlesTemp rl= get_leaves(reference);
algebra::Transformation3D tr
= algebra::get_transformation_aligning_first_to_second(rl, hl);
algebra::Transformation3D rtr
= core::RigidMember(reference).get_rigid_body().\
get_reference_frame().get_transformation_to();
algebra::Transformation3D rbtr= tr*rtr;
Particle *rbp= new Particle(h->get_model());
rbp->set_name(h->get_name()+" rigid body");
ParticlesTemp all = rb_process(h);
core::RigidBody rbd
= core::RigidBody::setup_particle(rbp, algebra::ReferenceFrame3D(rbtr));
for (unsigned int i=0; i< all.size(); ++i) {
rbd.add_member(all[i]);
}
rbd.set_coordinates_are_optimized(true);
IMP_INTERNAL_CHECK(h.get_is_valid(true), "Invalid hierarchy produced");
return rbd;
}
IMPATOM_BEGIN_NAMESPACE
CHARMMStereochemistryRestraint::CHARMMStereochemistryRestraint(Hierarchy h,
CHARMMTopology *topology):
Restraint(h->get_model(), "CHARMMStereochemistryRestraint%1%")
{
bonds_ = topology->add_bonds(h);
angles_ = topology->get_parameters()->create_angles(bonds_);
dihedrals_ = topology->get_parameters()->create_dihedrals(bonds_);
impropers_ = topology->add_impropers(h);
bond_score_ = new BondSingletonScore(new core::Harmonic(0., 1.));
angle_score_ = new AngleSingletonScore(new core::Harmonic(0., 1.));
dihedral_score_ = new DihedralSingletonScore();
improper_score_ = new ImproperSingletonScore(new core::Harmonic(0., 1.));
}
Hierarchy create_fragment(const Hierarchies &ps) {
IMP_USAGE_CHECK(!ps.empty(), "Need some particles");
Hierarchy parent = ps[0].get_parent();
unsigned int index = ps[0].get_child_index();
IMP_IF_CHECK(USAGE) {
for (unsigned int i = 0; i < ps.size(); ++i) {
IMP_USAGE_CHECK(ps[i].get_parent() == parent, "Parents don't match");
}
}
kernel::Particle *fp =
new kernel::Particle(parent.get_particle()->get_model());
Hierarchy fd = Fragment::setup_particle(fp);
for (unsigned int i = 0; i < ps.size(); ++i) {
parent.remove_child(ps[i]);
fd.add_child(ps[i]);
}
parent.add_child_at(fd, index);
return fd;
}
//! 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");
SetupMatrix(*Op);
SetupExtra(H);
// Setup Hierarchy
H.SetMaxCoarseSize(maxCoarseSize_);
H.SetDefaultVerbLevel(verbosity_);
if (graphOutputLevel_ >= 0)
H.EnableGraphDumping("dep_graph.dot", graphOutputLevel_);
// TODO: coarsestLevelManager
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++;
}
WriteData<Matrix>(H, matricesToPrint_, "A");
WriteData<Matrix>(H, prolongatorsToPrint_, "P");
WriteData<Matrix>(H, restrictorsToPrint_, "R");
} //SetupHierarchy
int main_(Teuchos::CommandLineProcessor &clp, Xpetra::UnderlyingLib lib, int argc, char *argv[]) {
#include <MueLu_UseShortNames.hpp>
using Teuchos::RCP;
using Teuchos::rcp;
//
// MPI initialization
//
Teuchos::oblackholestream blackhole;
bool success = false;
bool verbose = true;
try {
RCP< const Teuchos::Comm<int> > comm = Teuchos::DefaultComm<int>::getComm();
//
// Process command line arguments
//
Galeri::Xpetra::Parameters<GO> matrixParameters(clp, 81); // manage parameters of the test case
Xpetra::Parameters xpetraParameters(clp); // manage parameters of xpetra
switch (clp.parse(argc,argv)) {
case Teuchos::CommandLineProcessor::PARSE_HELP_PRINTED: return EXIT_SUCCESS;
case Teuchos::CommandLineProcessor::PARSE_ERROR:
case Teuchos::CommandLineProcessor::PARSE_UNRECOGNIZED_OPTION: return EXIT_FAILURE;
case Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL: break;
default:;
}
if (comm->getRank() == 0) std::cout << xpetraParameters << matrixParameters;
//
// Setup test case (Ax = b)
//
// Distribution
RCP<const Map> map = MapFactory::Build(lib, matrixParameters.GetNumGlobalElements(), 0, comm);
// Matrix
RCP<Galeri::Xpetra::Problem<Map,CrsMatrixWrap,MultiVector> > Pr =
Galeri::Xpetra::BuildProblem<SC, LO, GO, Map, CrsMatrixWrap, MultiVector>(matrixParameters.GetMatrixType(), map, matrixParameters.GetParameterList());
RCP<Matrix> A = Pr->BuildMatrix();
// User defined nullspace
RCP<MultiVector> nullSpace = VectorFactory::Build(map,1); nullSpace->putScalar((SC) 1.0);
// Define B
RCP<Vector> X = VectorFactory::Build(map,1);
RCP<Vector> B = VectorFactory::Build(map,1);
X->setSeed(846930886);
X->randomize();
A->apply(*X, *B, Teuchos::NO_TRANS, (SC)1.0, (SC)0.0);
// X = 0
X->putScalar((SC) 0.0);
//
// Create a multigrid configuration
//
// Transfer operators
RCP<TentativePFactory> TentativePFact = rcp( new TentativePFactory() );
RCP<SaPFactory> SaPFact = rcp( new SaPFactory() );
RCP<TransPFactory> RFact = rcp( new TransPFactory());
FactoryManager M;
M.SetFactory("Ptent", TentativePFact);
M.SetFactory("P", SaPFact);
M.SetFactory("R", RFact);
M.SetFactory("Smoother", Teuchos::null); //skips smoother setup
M.SetFactory("CoarseSolver", Teuchos::null); //skips coarsest solve setup
//
// Multigrid setup phase
//
int startLevel = 0;
int maxLevels = 10;
std::cout << "=============== Setup transfers only ====================" << std::endl;
Hierarchy H;
H.SetDefaultVerbLevel(MueLu::Medium);
RCP<Level> finestLevel = H.GetLevel();
finestLevel->Set("A", A);
finestLevel->Set("Nullspace", nullSpace);
// Indicate which Hierarchy operators we want to keep
H.Keep("P", SaPFact.get()); //SaPFact is the generating factory for P.
H.Keep("R", RFact.get()); //RFact is the generating factory for R.
H.Keep("Ptent", TentativePFact.get()); //SaPFact is the generating factory for P.
H.Setup(M,startLevel,maxLevels);
std::cout << "=============== Setup smoothers only ====================" << std::endl;
// Create a new A.
RCP<Matrix> newA = Pr->BuildMatrix();
finestLevel->Set("A", newA);
// Create Gauss-Seidel smoother.
std::string ifpackType = "RELAXATION";
Teuchos::ParameterList ifpackList;
ifpackList.set("relaxation: sweeps", (LO) 3);
ifpackList.set("relaxation: damping factor", (SC) 1.0);
RCP<SmootherPrototype> smootherPrototype = rcp(new TrilinosSmoother(ifpackType, ifpackList));
M.SetFactory("Smoother", rcp(new SmootherFactory(smootherPrototype)));
// Create coarsest solver.
RCP<SmootherPrototype> coarseSolverPrototype = rcp( new DirectSolver() );
RCP<SmootherFactory> coarseSolverFact = rcp( new SmootherFactory(coarseSolverPrototype, Teuchos::null) );
M.SetFactory("CoarseSolver", coarseSolverFact);
// Note that we pass the number of levels back in.
H.Setup(M,startLevel, H.GetNumLevels());
std::cout << "=============== Solve ====================" << std::endl;
//
// Solve Ax = B
//
LO nIts = 9;
H.Iterate(*B, *X, nIts);
//
// Print relative residual norm
//
typename Teuchos::ScalarTraits<SC>::magnitudeType residualNorms = Utilities::ResidualNorm(*A, *X, *B)[0];
if (comm->getRank() == 0) {
std::ios::fmtflags f(std::cout.flags());
std::cout << "||Residual|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(20) << residualNorms << std::endl;
std::cout.flags(f);
}
success = true;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(verbose, std::cerr, success);
return ( success ? EXIT_SUCCESS : EXIT_FAILURE );
}
void AdaptiveSaMLParameterListInterpreter<Scalar, LocalOrdinal, GlobalOrdinal, Node>::SetupHierarchy(Hierarchy & H) const {
// set fine level null space
// usually this null space is provided from outside (by the user) using
// the ML parameter lists.
if (this->nullspace_ != NULL) {
RCP<Level> fineLevel = H.GetLevel(0);
const RCP<const Map> rowMap = fineLevel->Get< RCP<Matrix> >("A")->getRowMap();
RCP<MultiVector> nullspace = MultiVectorFactory::Build(rowMap, nullspaceDim_, true);
for ( size_t i=0; i < Teuchos::as<size_t>(nullspaceDim_); i++) {
Teuchos::ArrayRCP<Scalar> nullspacei = nullspace->getDataNonConst(i);
const size_t myLength = nullspace->getLocalLength();
for (size_t j = 0; j < myLength; j++) {
nullspacei[j] = nullspace_[i*myLength + j];
}
}
fineLevel->Set("Nullspace", nullspace);
}
// keep aggregates
H.Keep("Aggregates", HierarchyManager::GetFactoryManager(0)->GetFactory("Aggregates").get());
///////////////////////////////
// build hierarchy for initialization
SetupInitHierarchy(H);
{
// do some iterations with the built hierarchy to improve the null space
Teuchos::RCP<MueLu::Level> Finest = H.GetLevel(0); // get finest level,MueLu::NoFactory::get()
Teuchos::RCP<MultiVector> nspVector2 = Finest->Get<Teuchos::RCP<MultiVector> >("Nullspace");
Xpetra::IO<Scalar,LocalOrdinal,GlobalOrdinal,Node>::Write("orig_nsp.vec", *nspVector2);
RCP<Matrix> Op = Finest->Get<RCP<Matrix> >("A");
Xpetra::IO<Scalar,LocalOrdinal,GlobalOrdinal,Node>::Write("A.mat", *Op);
Teuchos::RCP<MultiVector> homogRhsVec = MultiVectorFactory::Build(nspVector2->getMap(),nspVector2->getNumVectors(),true);
homogRhsVec->putScalar(0.0);
// do 1 multigrid cycle for improving the null space by "solving"
// A B_f = 0
// where A is the system matrix and B_f the fine level null space vectors
H.Iterate(*homogRhsVec, *nspVector2, 1, false);
// store improved fine level null space
Finest->Set("Nullspace",nspVector2);
Xpetra::IO<Scalar,LocalOrdinal,GlobalOrdinal,Node>::Write("new_nsp.vec", *nspVector2);
//H.Delete("CoarseSolver", init_levelManagers_[0]->GetFactory("CoarseSolver").get());
}
{
// do some clean up.
// remove all old default factories. Build new ones for the second build.
// this is a little bit tricky to understand
for(size_t k=0; k < HierarchyManager::getNumFactoryManagers(); k++) {
HierarchyManager::GetFactoryManager(k)->Clean();
//Teuchos::rcp_dynamic_cast<const SingleLevelFactoryBase>(HierarchyManager::GetFactoryManager(k)->GetFactory("Smoother"))->DisableMultipleCallCheck(); // after changing to MLParamterListInterpreter functions
}
// not sure about this. i only need it if Smoother is defined explicitely (not using default smoother)
// need this: otherwise RAPFactory::Build is complaining on level 0
// and TentativePFactory::Build is complaining on level 1
Teuchos::rcp_dynamic_cast<const TwoLevelFactoryBase>(HierarchyManager::GetFactoryManager(0)->GetFactory("A"))->DisableMultipleCallCheck();
Teuchos::rcp_dynamic_cast<const TwoLevelFactoryBase>(HierarchyManager::GetFactoryManager(1)->GetFactory("P"))->DisableMultipleCallCheck();
Teuchos::rcp_dynamic_cast<const TwoLevelFactoryBase>(HierarchyManager::GetFactoryManager(1)->GetFactory("Ptent"))->DisableMultipleCallCheck();
HierarchyManager::SetupHierarchy(H);
}
}
int main() {
int num_l;
int num_f;
int dim;
int i, j, n;
int size_base[3];
double bbox[6];
double *sigma1_n, *sigma2_n, *sigma1_np1, *sigma2_np1;
double* x, dx;
num_l = 11;
num_f = 4;
dim = 1;
size_base[0] = 3;
size_base[1] = 3;
size_base[2] = 3;
bbox[0] = -1;
bbox[1] = 1;
bbox[2] = -1;
bbox[3] = 1;
bbox[4] = -1;
bbox[5] = 1;
Hierarchy* hierarchy = new Hierarchy(num_l, num_f, dim, size_base, bbox);
n = hierarchy->fields[num_l - 1][0]->n;
sigma1_n = hierarchy->fields[num_l - 1][0]->f1d;
sigma2_n = hierarchy->fields[num_l - 1][1]->f1d;
sigma1_np1 = hierarchy->fields[num_l - 1][2]->f1d;
sigma2_np1 = hierarchy->fields[num_l - 1][3]->f1d;
x = hierarchy->coords[num_l - 1]->mesh[0]->f1d;
dx = x[1] - x[0];
for (i = 0; i < n; i++) {
sigma1_n[i] = -sin(x[i]*M_PI/2.0-M_PI/2.0);
sigma2_n[i] = 0;
sigma1_np1[i] = -sin(x[i]*M_PI/2.0-M_PI/2.0);
sigma2_np1[i] = 0;
}
double begin, end;
double time_spent;
//omp_set_num_threads(2);
//printf("begin\n");
//begin = omp_get_wtime();
//hierarchy->relaxLevel(4, 1, num_l-1, f_schrodinger_opp_1d, f_schrodinger_res_1d, f_schrodinger_jac_1d);
double t = 0.1;
for (j = 0; j < t/(0.1*dx); j++)
{
printf("step:\n\n");
for (i = 0; i < 20; i++) {
hierarchy->vCycle(4, dx*0.1, f_schrodinger_opp_1d,
f_schrodinger_jac_1d);
printf("change %e, residual %e\n", hierarchy->change[num_l - 1],
hierarchy->resid[num_l - 1]);
}
hierarchy->switchFields(0,2);
hierarchy->switchFields(1,3);
}
hierarchy->switchFields(0,2);
hierarchy->switchFields(1,3);
//printf("after:\n");
//end = omp_get_wtime();
//time_spent = (end - begin);
//printf("time spent: %lf\n", time_spent);
//hierarchy->print(num_l-1);
f_schrodinger_indep_resid_1d(dx*0.1, hierarchy->coords[num_l-1], hierarchy->fields[num_l-1]);
delete hierarchy;
return 0;
}
Hierarchy create_simplified_along_backbone(Chain in,
const IntRanges &residue_segments,
bool keep_detailed) {
IMP_USAGE_CHECK(in.get_is_valid(true), "Chain " << in << " is not valid.");
if (in.get_number_of_children() == 0 || residue_segments.empty()) {
IMP_LOG_TERSE("Nothing to simplify in "
<< (in ? in->get_name() : "nullptr") << " with "
<< residue_segments.size() << " segments.\n");
return Hierarchy();
}
for (unsigned int i = 0; i < residue_segments.size(); ++i) {
IMP_USAGE_CHECK(residue_segments[i].first < residue_segments[i].second,
"Residue intervals must be non-empty");
}
IMP_IF_LOG(VERBOSE) {
for (unsigned int i = 0; i < residue_segments.size(); ++i) {
IMP_LOG_VERBOSE("[" << residue_segments[i].first << "..."
<< residue_segments[i].second << ") ");
}
IMP_LOG_VERBOSE(std::endl);
}
unsigned int cur_segment = 0;
Hierarchies cur;
Hierarchy root = create_clone_one(in);
for (unsigned int i = 0; i < in.get_number_of_children(); ++i) {
Hierarchy child = in.get_child(i);
int index = Residue(child).get_index();
IMP_LOG_VERBOSE("Processing residue "
<< index << " with range "
<< residue_segments[cur_segment].first << " "
<< residue_segments[cur_segment].second << std::endl);
if (index >= residue_segments[cur_segment].first &&
index < residue_segments[cur_segment].second) {
} else if (!cur.empty()) {
IMP_LOG_VERBOSE("Added particle for "
<< residue_segments[cur_segment].first << "..."
<< residue_segments[cur_segment].second << std::endl);
Hierarchy cur_approx = create_approximation_of_residues(cur);
root.add_child(cur_approx);
if (keep_detailed) {
for (unsigned int j = 0; j < cur.size(); ++j) {
cur[j].get_parent().remove_child(cur[j]);
cur_approx.add_child(cur[j]);
}
}
cur.clear();
++cur_segment;
}
cur.push_back(child);
}
if (!cur.empty()) {
root.add_child(create_approximation_of_residues(cur));
}
/*#ifdef IMP_ATOM_USE_IMP_CGAL
double ov= get_volume(in);
double cv= get_volume(root);
double scale=1;
ParticlesTemp rt= get_by_type(root, XYZR_TYPE);
Floats radii(rt.size());
for (unsigned int i=0; i< rt.size(); ++i) {
core::XYZR d(rt[i]);
radii[i]=d.get_radius();
}
do {
show(root);
double f= ov/cv*scale;
scale*=.95;
IMP_LOG_TERSE( "Bumping radius by " << f << std::endl);
for (unsigned int i=0; i< rt.size(); ++i) {
core::XYZR d(rt[i]);
d.set_radius(radii[i]*f);
}
double nv=get_volume(root);
IMP_LOG_TERSE( "Got volume " << nv << " " << ov << std::endl);
if (nv < ov) {
break;
}
} while (true);
#else
#endif*/
IMP_INTERNAL_CHECK(root.get_is_valid(true), "Invalid hierarchy produced "
<< root);
return root;
}
Selection::Selection(Hierarchy h) : radius_(-1) {
set_hierarchies(h.get_model(),
kernel::ParticleIndexes(1, h.get_particle_index()));
}
void keyStateChanged(int key, int mods)
{
switch (key) {
case GLFW_KEY_A:
g_armature.AdjBase(true);
break;
case GLFW_KEY_D:
g_armature.AdjBase(false);
break;
case GLFW_KEY_W:
g_armature.AdjUpperArm(false);
break;
case GLFW_KEY_S:
g_armature.AdjUpperArm(true);
break;
case GLFW_KEY_R:
g_armature.AdjLowerArm(false);
break;
case GLFW_KEY_F:
g_armature.AdjLowerArm(true);
break;
case GLFW_KEY_T:
g_armature.AdjWristPitch(false);
break;
case GLFW_KEY_G:
g_armature.AdjWristPitch(true);
break;
case GLFW_KEY_Z:
g_armature.AdjWristRoll(true);
break;
case GLFW_KEY_C:
g_armature.AdjWristRoll(false);
break;
case GLFW_KEY_Q:
g_armature.AdjFingerOpen(true);
break;
case GLFW_KEY_E:
g_armature.AdjFingerOpen(false);
break;
case GLFW_KEY_ENTER:
g_armature.WritePose();
break;
}
}
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;
}
int main(int argc, char *argv[]) {
#include "MueLu_UseShortNames.hpp"
using Teuchos::RCP; using Teuchos::rcp;
using Teuchos::TimeMonitor;
Teuchos::oblackholestream blackhole;
Teuchos::GlobalMPISession mpiSession(&argc,&argv,&blackhole);
bool success = false;
bool verbose = true;
try {
RCP<const Teuchos::Comm<int> > comm = Teuchos::DefaultComm<int>::getComm();
RCP<Teuchos::FancyOStream> out = Teuchos::fancyOStream(Teuchos::rcpFromRef(std::cout));
out->setOutputToRootOnly(0);
*out << MueLu::MemUtils::PrintMemoryUsage() << std::endl;
//#ifndef HAVE_XPETRA_INT_LONG_LONG
*out << "Warning: scaling test was not compiled with long long int support" << std::endl;
//#endif
/**********************************************************************************/
/* SET TEST PARAMETERS */
/**********************************************************************************/
// Note: use --help to list available options.
Teuchos::CommandLineProcessor clp(false);
Xpetra::Parameters xpetraParameters(clp); // manage parameters of xpetra
switch (clp.parse(argc,argv)) {
case Teuchos::CommandLineProcessor::PARSE_HELP_PRINTED: return EXIT_SUCCESS; break;
case Teuchos::CommandLineProcessor::PARSE_ERROR:
case Teuchos::CommandLineProcessor::PARSE_UNRECOGNIZED_OPTION: return EXIT_FAILURE; break;
case Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL: break;
}
//RCP<TimeMonitor> globalTimeMonitor = rcp (new TimeMonitor(*TimeMonitor::getNewTimer("ScalingTest: S - Global Time")));
xpetraParameters.check();
Xpetra::UnderlyingLib lib = xpetraParameters.GetLib();
if (comm->getRank() == 0) {
std::cout << xpetraParameters;
// TODO: print custom parameters // Or use paramList::print()!
}
/**********************************************************************************/
/* CREATE INITIAL MATRIX */
/**********************************************************************************/
RCP<const Map> bigMap;
RCP<const Map> map1;
RCP<const Map> map2;
GO numElements = 500;
GO numElements1 = 400;
GO numElements2 = 100;
//bigMap = MapFactory::Build(Xpetra::UseEpetra, numElements, 0, comm); // ok this is the problem :-)
std::vector<size_t> stridingInfo;
stridingInfo.push_back(1);
map1 = StridedMapFactory::Build(lib, numElements1, 0, stridingInfo, comm, -1);
map2 = StridedMapFactory::Build(lib, numElements2, numElements1, stridingInfo, comm, -1);
std::vector<GlobalOrdinal> localGids; // vector with all local GIDs on cur proc
Teuchos::ArrayView< const GlobalOrdinal > map1eleList = map1->getNodeElementList(); // append all local gids from map1 and map2
localGids.insert(localGids.end(), map1eleList.begin(), map1eleList.end());
Teuchos::ArrayView< const GlobalOrdinal > map2eleList = map2->getNodeElementList();
localGids.insert(localGids.end(), map2eleList.begin(), map2eleList.end());
Teuchos::ArrayView<GlobalOrdinal> eleList(&localGids[0],localGids.size());
bigMap = StridedMapFactory::Build(lib, numElements, eleList, 0, stridingInfo, comm); // create full big map (concatenation of map1 and map2)
std::vector<Teuchos::RCP<const Map> > maps;
maps.push_back(map1); maps.push_back(map2);
Teuchos::RCP<const Xpetra::MapExtractor<Scalar, LO, GO, Node> > mapExtractor = Xpetra::MapExtractorFactory<Scalar,LO,GO,Node>::Build(bigMap, maps);
RCP<CrsMatrixWrap> Op11 = MueLuTests::GenerateProblemMatrix(map1,2,-1,-1);
RCP<CrsMatrixWrap> Op22 = MueLuTests::GenerateProblemMatrix(map2,3,-2,-1);
/*Op11->describe(*out,Teuchos::VERB_EXTREME);
Op22->describe(*out,Teuchos::VERB_EXTREME);*/
// build blocked operator
Teuchos::RCP<Xpetra::BlockedCrsMatrix<Scalar,LO,GO,Node> > bOp = Teuchos::rcp(new Xpetra::BlockedCrsMatrix<Scalar,LO,GO>(mapExtractor,mapExtractor,10));
Teuchos::RCP<Xpetra::CrsMatrix<Scalar,LO,GO,Node> > crsMat11 = Op11->getCrsMatrix();
Teuchos::RCP<Xpetra::CrsMatrix<Scalar,LO,GO,Node> > crsMat22 = Op22->getCrsMatrix();
bOp->setMatrix(0,0,crsMat11);
bOp->setMatrix(1,1,crsMat22);
bOp->fillComplete();
// build hierarchy
Hierarchy H;
H.SetMaxCoarseSize(50);
RCP<Level> levelOne = H.GetLevel();
levelOne->Set("A", Teuchos::rcp_dynamic_cast<Matrix>(bOp)); // set blocked operator
RCP<SubBlockAFactory> A11Fact = Teuchos::rcp(new SubBlockAFactory());
A11Fact->SetFactory("A",MueLu::NoFactory::getRCP());
A11Fact->SetParameter("block row",Teuchos::ParameterEntry(0));
A11Fact->SetParameter("block col",Teuchos::ParameterEntry(0));
RCP<SubBlockAFactory> A22Fact = Teuchos::rcp(new SubBlockAFactory());
A22Fact->SetFactory("A",MueLu::NoFactory::getRCP());
A22Fact->SetParameter("block row",Teuchos::ParameterEntry(1));
A22Fact->SetParameter("block col",Teuchos::ParameterEntry(1));
RCP<TentativePFactory> P11Fact = rcp(new TentativePFactory());
RCP<TransPFactory> R11Fact = rcp(new TransPFactory());
RCP<TentativePFactory> P22TentFact = rcp(new TentativePFactory());
RCP<PgPFactory> P22Fact = rcp(new PgPFactory());
RCP<GenericRFactory> R22Fact = rcp(new GenericRFactory());
std::string ifpackType;
Teuchos::ParameterList ifpackList;
ifpackList.set("relaxation: sweeps", (LO) 5);
ifpackList.set("relaxation: damping factor", (SC) 1.0);
ifpackType = "RELAXATION";
ifpackList.set("relaxation: type", "Symmetric Gauss-Seidel");
RCP<SmootherPrototype> smoProto11 = rcp( new TrilinosSmoother(ifpackType, ifpackList, 0) );
smoProto11->SetFactory("A", A11Fact);
RCP<SmootherPrototype> smoProto22 = rcp( new TrilinosSmoother(ifpackType, ifpackList, 0) );
smoProto22->SetFactory("A", A22Fact);
//RCP<SmootherPrototype> smoProto11 = rcp( new DirectSolver("", Teuchos::ParameterList(), A11Fact) );
//RCP<SmootherPrototype> smoProto22 = rcp( new DirectSolver("", Teuchos::ParameterList(), A22Fact) );
RCP<SmootherFactory> Smoo11Fact = rcp( new SmootherFactory(smoProto11) );
RCP<SmootherFactory> Smoo22Fact = rcp( new SmootherFactory(smoProto22) );
RCP<FactoryManager> M11 = rcp(new FactoryManager());
M11->SetFactory("A", A11Fact);
M11->SetFactory("P", P11Fact);
M11->SetFactory("Ptent", P11Fact); //for Nullspace
M11->SetFactory("R", R11Fact);
M11->SetFactory("Smoother", Smoo11Fact);
M11->SetIgnoreUserData(true);
RCP<FactoryManager> M22 = rcp(new FactoryManager());
M22->SetFactory("A", A22Fact);
M22->SetFactory("P", P22Fact);
M22->SetFactory("R", R22Fact);
M22->SetFactory("Ptent", P22TentFact); //for both P22 and Nullspace
M22->SetFactory("Smoother", Smoo22Fact);
M22->SetIgnoreUserData(true);
RCP<BlockedPFactory> PFact = rcp(new BlockedPFactory());
PFact->AddFactoryManager(M11);
PFact->AddFactoryManager(M22);
RCP<GenericRFactory> RFact = rcp(new GenericRFactory());
RCP<Factory> AcFact = rcp(new BlockedRAPFactory());
// Smoothers
RCP<BlockedGaussSeidelSmoother> smootherPrototype = rcp( new BlockedGaussSeidelSmoother() );
smootherPrototype->SetParameter("Sweeps", Teuchos::ParameterEntry(2));
smootherPrototype->SetParameter("Damping factor", Teuchos::ParameterEntry(1.0));
smootherPrototype->AddFactoryManager(M11,0);
smootherPrototype->AddFactoryManager(M22,1);
RCP<SmootherFactory> smootherFact = rcp( new SmootherFactory(smootherPrototype) );
// Coarse grid correction
RCP<BlockedGaussSeidelSmoother> coarseSolverPrototype = rcp( new BlockedGaussSeidelSmoother() );
coarseSolverPrototype->AddFactoryManager(M11,0);
coarseSolverPrototype->AddFactoryManager(M22,1);
RCP<SmootherFactory> coarseSolverFact = rcp( new SmootherFactory(coarseSolverPrototype, Teuchos::null) );
// main factory manager
FactoryManager M;
M.SetFactory("A", AcFact);
M.SetFactory("P", PFact);
M.SetFactory("R", RFact);
M.SetFactory("Smoother", smootherFact); // TODO fix me
M.SetFactory("CoarseSolver", coarseSolverFact);
H.SetVerbLevel(MueLu::Test);
H.Setup(M);
std::cout << "main AcFact = " << AcFact.get() << std::endl;
RCP<Level> l0 = H.GetLevel(0);
RCP<Level> l1 = H.GetLevel(1);
RCP<Level> l2 = H.GetLevel(2);
l0->print(*out,Teuchos::VERB_EXTREME);
l1->print(*out,Teuchos::VERB_EXTREME);
l2->print(*out,Teuchos::VERB_EXTREME);
// Define B
RCP<Vector> X = VectorFactory::Build(bigMap,1);
RCP<Vector> B = VectorFactory::Build(bigMap,1);
X->setSeed(846930886);
X->randomize();
bOp->apply(*X, *B, Teuchos::NO_TRANS, (SC)1.0, (SC)0.0);
// X = 0
X->putScalar((SC) 0.0);
LO nIts = 9;
H.Iterate(*B, *X, nIts);
success = true;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(verbose, std::cerr, success);
return ( success ? EXIT_SUCCESS : EXIT_FAILURE );
}
//! Setup Hierarchy object
virtual void SetupHierarchy(Hierarchy& H) const {
TEUCHOS_TEST_FOR_EXCEPTION(!H.GetLevel(0)->IsAvailable("A"), Exceptions::RuntimeError, "No fine level operator");
#ifdef HAVE_MUELU_DEBUG
// Reset factories' data used for debugging
for (int i = 0; i < levelManagers_.size(); i++)
levelManagers_[i]->ResetDebugData();
#endif
// 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_);
H.SetPRrebalance(doPRrebalance_);
H.SetImplicitTranspose(implicitTranspose_);
// 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
/*************************************************************
* another kind of function that return a set
************************************************************/
std::vector<QueryTuple*> SetFunFactory::funInstance(XSchema* _pSch,
std::string& _cubeName,
SetTypesec _typesec,
std::vector<std::string>& theVector)
{
int size = theVector.size();
XCube* pCube = _pSch->getCube(_cubeName);
vector<QueryMember*> QmemVector;
vector<QueryTuple*> QtupleVector;
switch(_typesec)
{
//函数Members的处理对象
//对于[Time].[Time].[1995].[Q1].[Month].Members
//theVector中应依次存有string：Time, Time, 1995, Q1, Month
case Members:
if (size == 0 )
{
cout<<"error! please input query information..."<<endl;
}
else if (size == 1) //由于现在还不支持多个Hierarchy，所以size 为1、2结果是一样的
{
if ((theVector.at(0) == "Measures")||(theVector.at(0) == "measures"))
{
//元数据现在还没有支持默认度量，先以第一个度量为默认的
vector<Measure*> vecMea = pCube->getMeasures();
vector<Measure*>::iterator meaIterator;
if (!vecMea.empty())
{
for (meaIterator = vecMea.begin(); meaIterator < vecMea.end(); meaIterator++)
{
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setHierarchyName("Measures");
pMem->setLevelName("Measures");
pMem->setVal((*meaIterator)->getName());
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
}
return QtupleVector;
}
else
{
Dimension* pDim = pCube->getDimension(theVector.at(0));
if (!pDim)
{
cout<<"error! wrong dimension name...."<<endl;
}
else
{
//是取默认Hierarchy
//获得的QueryMember应该是最细粒度的所有的QueryMember
//所以在这里要作笛卡儿积（并不算纯粹的笛卡儿积），见for循环
vector< Hierarchy* > hieVector = pDim->getHierarchies();
Hierarchy* pHie = hieVector.at(0);//取第一个为默认Hierarchy
//首先把Member从数据库中load出来
pHie->LoadMembers();
string hierarcyName = pHie->getName();
vector<string> vecLevelName;
vector< vector<string> > memNameInLevels;//用于存储每个Level上成员名字的vector
vector<Level*> vecLevel = pHie->getLeveles();
int levelSize = vecLevel.size();
Level* pLevel = vecLevel.at(levelSize-1);
string levelName = pLevel->getName();
vector<Member*> vecMem = pLevel->getMembers();
vector<Member*>::iterator memIterator;
for (memIterator = vecMem.begin(); memIterator < vecMem.end(); memIterator++)
{
string memberVal = (*memIterator)->getKey();
vector<string> vecAncestorVal;
vector<string> vecAncestorLevel;
vector<Member*> vecParentMems;
vector<Member*>::iterator pMemIterator;
vecParentMems = (*memIterator)->getAllParents();
for (pMemIterator = vecParentMems.begin(); pMemIterator < vecParentMems.end(); pMemIterator++)
{
string parentVal = (*pMemIterator)->getKey();
Level* pLevel = (*pMemIterator)->getLevel();
string parentLevel = pLevel->getName();
vecAncestorVal.push_back(parentVal);
vecAncestorLevel.push_back(parentLevel);
}
std::auto_ptr<QueryMember>p(new QueryMember);
p->setHierarchyName(hierarcyName);
p->setAncestorVals(vecAncestorVal);
p->setAncestorLevels(vecAncestorLevel);
p->setVal(memberVal);
p->setLevelName(levelName);
QmemVector.push_back(p.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
}
}
else if (size == 2)
{
string dimName = theVector.at(0);
Dimension* pDim = pCube->getDimension(dimName);
if (pDim == NULL)
{
cout<<"null point to dimension"<<endl;
}
Hierarchy* pHie = pDim->getHierarchy(theVector.at(1));
if (pHie == NULL)
{
cout<<"null point to Hierarchy"<<endl;
}
//首先把Member从数据库中load出来
pHie->LoadMembers();
string hierarcyName = pHie->getName();
vector<string> vecLevelName;
vector< vector<string> > memNameInLevels;//用于存储每个Level上成员名字的vector
vector<Level*> vecLevel = pHie->getLeveles();
int levelSize = vecLevel.size();
Level* pLevel = vecLevel.at(levelSize-1);
string levelName = pLevel->getName();
vector<Member*> vecMem = pLevel->getMembers();
vector<Member*>::iterator memIterator;
for (memIterator = vecMem.begin(); memIterator < vecMem.end(); memIterator++)
{
string memberVal = (*memIterator)->getKey();
vector<string> vecAncestorVal;
vector<string> vecAncestorLevel;
vector<Member*> vecParentMems;
vector<Member*>::iterator pMemIterator;
vecParentMems = (*memIterator)->getAllParents();
for (pMemIterator = vecParentMems.begin(); pMemIterator < vecParentMems.end(); pMemIterator++)
{
string parentVal = (*pMemIterator)->getKey();
Level* pLevel = (*pMemIterator)->getLevel();
string parentLevel = pLevel->getName();
vecAncestorVal.push_back(parentVal);
vecAncestorLevel.push_back(parentLevel);
}
std::auto_ptr<QueryMember>p(new QueryMember);
p->setHierarchyName(hierarcyName);
p->setAncestorVals(vecAncestorVal);
p->setAncestorLevels(vecAncestorLevel);
p->setVal(memberVal);
p->setLevelName(levelName);
QmemVector.push_back(p.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
else if(size == 3)
{
Dimension* pDim = pCube->getDimension(theVector.at(0));
Hierarchy* pHie = pDim->getHierarchy(theVector.at(1));
//首先把Member从数据库中load出来
pHie->LoadMembers();
Level* pLevel = pHie->getLevel(theVector.at(2));
vector<Member*> memVector1;
memVector1 = pLevel->getMembers();
if (memVector1.empty())
{
cout<<"empty member vector,do not get the members from database"<<endl;
}
else{
vector<Member*>::iterator theIterator;
for (theIterator = memVector1.begin(); theIterator < memVector1.end(); theIterator++)
{
if (*theIterator == NULL)
{
cout<<"do not get the members from the database!"<<endl;
}
string QueryMemberVal = (*theIterator)->getKey();
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setVal(QueryMemberVal);
pMem->setLevelName(theVector.at(2));
pMem->setHierarchyName(theVector.at(1));
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
}
else//出现成员等于或多于一个的情况 eg. [Time].[Time].[1995].[Q1].[Month].Members
{
Dimension* pDim = pCube->getDimension(theVector.at(0));
Hierarchy* pHie = pDim->getHierarchy(theVector.at(1));
//首先把Member从数据库中load出来
pHie->LoadMembers();
Level* pLevel = pHie->getLevel(theVector.at(size-1));
vector<Member*> memVector = pLevel->getMembers();
vector<Member*>::iterator theIterator;
for (theIterator = memVector.begin(); theIterator < memVector.end(); theIterator++)
{
string QueryMemberVal = (*theIterator)->getKey();
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setVal(QueryMemberVal);
pMem->setLevelName(theVector.at(size));
pMem->setHierarchyName(theVector.at(1));
vector<string> ancestorVals;
vector<string> ancestorLevles;
for (int i = 2; i < size-1; i++)
{
vector<Level*> levelVec;
levelVec = pHie->getLeveles();
ancestorVals.push_back(theVector.at(i));
Level* p = levelVec.at(i);
ancestorLevles.push_back(p->getName());
}
pMem->setAncestorVals(ancestorVals);
pMem->setAncestorLevels(ancestorLevles);
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
break;
//函数AllMembers,参考SQL Server联机丛书
//返回包含指定维度或级别的所有成员的集合，包括计算成员。
//注：暂时不考虑计算成员的处理,此时功能和Members功能差不多
case AllMembers:
if (size == 0 )
{
cout<<"error! please input the query information!"<<endl;
}
else if (size == 1)
{
//取得默认Hierarchy
//暂时只支持一个Hierarchy，即和维度名相同
string dimensionName = theVector.at(0);
string hierarchyName = dimensionName;
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setVal("All");
pMem->setHierarchyName(hierarchyName);
pMem->setLevelName("All");
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
return QtupleVector;
}
else if(size == 2)//[Time].[Time].AllMembers
{
string dimensionName = theVector.at(0);
Dimension* pDim = pCube->getDimension(dimensionName);
Hierarchy* pHie = pDim->getHierarchy(theVector.at(1));
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setHierarchyName(pHie->getName());
pMem->setLevelName("All");
pMem->setVal("All");
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
return QtupleVector;
}
else //[Time].[Time].[Year].AllMembers
{
Dimension* pDim = pCube->getDimension(theVector.at(0));
Hierarchy* pHie = pDim->getHierarchy(theVector.at(1));
Level* pLevel = pHie->getLevel(theVector.at(size-1));
vector<Member*> memVector = pLevel->getMembers();
vector<Member*>::iterator theIterator;
for (theIterator = memVector.begin(); theIterator < memVector.end(); theIterator++)
{
string QueryMemberVal = (*theIterator)->getKey();
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setVal(QueryMemberVal);
pMem->setLevelName(theVector.at(size));
pMem->setHierarchyName(theVector.at(1));
vector<string> ancestorVals;
vector<string> ancestorLevles;
for (int i = 2; i < size-1; i++)
{
vector<Level*> levelVec;
levelVec = pHie->getLeveles();
ancestorVals.push_back(theVector.at(i));
Level* p = levelVec.at(i);
ancestorLevles.push_back(p->getName());
}
pMem->setAncestorVals(ancestorVals);
pMem->setAncestorLevels(ancestorLevles);
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
//pHie->CleanMembers();没有加载过member
return QtupleVector;
}
break;
case Children:
//注：JPivot里面是不可能出现这种情况的
//因为一旦出现，JPivot会自动转化成加一个CurrentMember函数
//如：[Time].Children会自动转变成[Time].CurrentMember.Children
string dimName = "";
string hieName = "";
bool isall = false;
if (size == 1)
{
cout<<"error! invalid using of Children"<<endl;
}
else if(size == 2)
{
Dimension* pDim =NULL;
Hierarchy* pHie = NULL;
if (isDimHie(theVector.at(0)))
{
vector<string> temp = distinct(theVector.at(0));
dimName = temp.at(0);
pDim = pCube->getDimension(dimName);
assert(pDim);
hieName = temp.at(1);
Hierarchy* pHie = pDim->getHierarchy(hieName);
assert(pHie);
}
else
{
dimName = theVector.at(0);
pDim = pCube->getDimension(theVector.at(0));
assert(pDim);
pHie = pDim->getDefaultHierarchy();
hieName = pHie->getName();
assert(pHie);
}
assert(pHie);
pHie->LoadMembers();
vector<Level*> levelVec = pHie->getLeveles();
Level* pLevel1 = levelVec.at(0);//父member所在的level
assert(pLevel1);
string ancestorVal = theVector.at(1);
string ancestorLevel = pLevel1->getName();
vector<string> valVec;
vector<string> theVec;
valVec.push_back(ancestorVal);
theVec.push_back(ancestorLevel);
Level* pLevel2 = levelVec.at(1);//查询的member所在的level
string QueryMemberLevel = pLevel2->getName();
// cout<<"value:"<<theVector.at(1)<<endl;
Member* pm = pLevel1->getMember(theVector.at(1),NULL);////////////////////////////////
vector<Member*> memVec = pm->getChildrenMember();
//cout<<QueryMemberLevel<<" "<<memVec.size()<<endl;
vector<Member*>::iterator memIterator;
for (memIterator = memVec.begin(); memIterator < memVec.end(); memIterator++)
{
string QueryMemberVal = (*memIterator)->getKey();
std::auto_ptr<QueryMember>p(new QueryMember(dimName,hieName,QueryMemberLevel,QueryMemberVal,valVec,theVec,isall));
QmemVector.push_back(p.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
else if (size >= 2)
{
Dimension* pDim = NULL;
Hierarchy* pHie = NULL;
if (isDimHie(theVector.at(0)))
{
vector<string> temp = distinct(theVector.at(0));
dimName = temp.at(0);
pDim = pCube->getDimension(temp.at(0));
assert(pDim);
hieName = temp.at(1);
pHie = pDim->getHierarchy(temp.at(1));
assert(pHie);
}
else
{
dimName = theVector.at(0);
pDim = pCube->getDimension(theVector.at(0));
assert(pDim);
pHie = pDim->getDefaultHierarchy();
}
assert(pHie);
string hieName = pHie->getName();
pHie->LoadMembers();
vector<Level*> levelVec = pHie->getLeveles();
//children members'level
Level* pLevel = levelVec.at(size-1);
vector<Level*> parentLevels;
vector<Level*>::iterator levelIterator;
parentLevels.assign(levelVec.begin(),levelVec.begin()+size-1);
vector<string> ancestorVal;
vector<string> ancestorLevel;
for (int i = 1; i < size; i++)
{
ancestorVal.push_back(theVector.at(i));
}
for (levelIterator = parentLevels.begin(); levelIterator < parentLevels.end(); levelIterator++)
{
string ancestorLevelName = (*levelIterator)->getName();
ancestorLevel.push_back(ancestorLevelName);
}
string firstparentMemVal = theVector.at(1);
Member* firstparentMem = parentLevels.at(0)->getMember(firstparentMemVal, NULL);
Member* lastParentMem = NULL;
if (size == 2)
{
assert(firstparentMem);
lastParentMem = firstparentMem;
}
else
{
for(int n = 2; n < size; n++)
{
//cout<<"theVector.at(n)"<<theVector.at(n)<<endl;
firstparentMem = parentLevels.at(n-1)->getMember(theVector.at(n), firstparentMem);
assert(firstparentMem);
}
}
lastParentMem = firstparentMem;
assert(lastParentMem);
vector<Member*> memVec = lastParentMem->getChildrenMember();
vector<Member*>::iterator memIterator;
for (memIterator = memVec.begin(); memIterator < memVec.end(); memIterator++)
{
string QueryMemberVal = (*memIterator)->getKey();
std::auto_ptr<QueryMember>ptr(new QueryMember);
ptr->setVal(QueryMemberVal);
ptr->setLevelName(pLevel->getName());
ptr->setHierarchyName(hieName);
ptr->setDimensionName(dimName);
ptr->setAncestorVals(ancestorVal);
ptr->setAncestorLevels(ancestorLevel);
ptr->setIsAll(isall);
QmemVector.push_back(ptr.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
break;
//下一个函数起点
}
}
void Process::setHierarchy(Hierarchy hierarchy) throw() {
Id id_copy = Id(getId()->getString());
hierarchy_.setHierarchy(hierarchy.getHierarchy());
hierarchy_.lowerLevel(id_copy);
}
/*************************************************************
* another kind of function that return a set
************************************************************/
std::vector<QueryTuple*> SetFunFactory::funInstance(XSchema* _pSch,
std::string& _cubeName,
SetTypesec _typesec,
std::vector<std::string>& theVector,
FunParam *param)
{
int size = theVector.size();
XCube* pCube = _pSch->getCube(_cubeName);
vector<QueryMember*> QmemVector;
vector<QueryTuple*> QtupleVector;
string dimName = "";
string hieName = "";
Dimension* pDim = NULL;
Hierarchy* pHie = NULL;
if (isDimHie(theVector.at(0)))
{
vector<string> temp = distinct(theVector.at(0));
dimName = temp.at(0);
pDim = pCube->getDimension(temp.at(0));
assert(pDim);
hieName = temp.at(1);
pHie = pDim->getHierarchy(temp.at(1));
assert(pHie);
}
else
{
dimName = theVector.at(0);
pDim = pCube->getDimension(theVector.at(0));
assert(pDim);
pHie = pDim->getDefaultHierarchy();
}
assert(pHie);
hieName = pHie->getName();
//首先把Member从数据库中load出来
pHie->LoadMembers();
switch(_typesec)
{
//函数Members的处理对象
//对于[Time].[Time].[1995].[Q1].[Month].Members
//theVector中应依次存有string：Time, Time, 1995, Q1, Month
case Members:
if (size == 0 )
{
cout<<"error! please input query information..."<<endl;
}
else if (size == 1) //由于现在还不支持多个Hierarchy，所以size 为1、2结果是一样的
{
if ((theVector.at(0) == "Measures")||(theVector.at(0) == "measures"))
{
//元数据现在还没有支持默认度量，先以第一个度量为默认的
vector<Measure*> vecMea = pCube->getMeasures();
vector<Measure*>::iterator meaIterator;
if (!vecMea.empty())
{
for (meaIterator = vecMea.begin(); meaIterator < vecMea.end(); meaIterator++)
{
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setHierarchyName("Measures");
pMem->setLevelName("Measures");
pMem->setVal((*meaIterator)->getName());
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
}
return QtupleVector;
}
else
{
string hierarcyName = pHie->getName();
vector<string> vecLevelName;
// vector< vector<string> > memNameInLevels;//用于存储每个Level上成员名字的vector
vector<Level*> vecLevel = pHie->getLeveles();
Member* temp = (vecLevel.at(0)->getMembers()).at(0);//获取第一个级别第一个成员
getDescendants(temp,dimName,hieName,QtupleVector); // 获取该成员的所有后代
pHie->CleanMembers();
return QtupleVector;
}
}
else if (size == 2)
{
Level* pLevel = pHie->getLevel(theVector.at(1));
vector<Member *> memVector1 = pLevel->getMembers();
if (memVector1.empty())
{
cout<<"empty member vector,do not get the members from database"<<endl;
}
else
{
vector<Member*>::iterator theIterator;
QueryMember *pMem;
for (theIterator = memVector1.begin(); theIterator < memVector1.end(); theIterator++)
{
pMem = DwMemToQryMem(*theIterator,dimName,hieName);
QmemVector.push_back(pMem);
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
}
else if(size >= 3) // [Time.Time].[Month].[Day].Members
{
cout<<"Members funtion error,too much member"<<endl;
return 0;
}
break;
//函数AllMembers,参考SQL Server联机丛书
//返回包含指定维度或级别的所有成员的集合，包括计算成员。
//注：暂时不考虑计算成员的处理,此时功能和Members功能差不多
case AllMembers:
if (size == 0 )
{
cout<<"error! please input the query information!"<<endl;
}
else
{
if (size == 1)
{
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setVal("All");
pMem->setDimensionName(dimName); // add by eason
pMem->setHierarchyName(hieName);
pMem->setLevelName("All");
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
return QtupleVector;
}
else if(size == 2)//[Time].[Quarter].AllMembers
{
pHie->LoadMembers(); //首先把Member从数据库中load出来 add by eason
Level* pLevel = pHie->getLevel(theVector.at(size-1));
vector<Member*> memVector = pLevel->getMembers();
vector<Member*>::iterator theIterator;
QueryMember *pMem;
for (theIterator = memVector.begin(); theIterator < memVector.end(); theIterator++)
{
pMem = DwMemToQryMem(*theIterator,dimName,hieName);
QmemVector.push_back(pMem);
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
else //[Time].[Year].[Month].AllMembers
{
cout<<"AllMembers funtion error,too much member"<<endl;
return 0;
}
}
break;
case Children:
{
//注：JPivot里面是不可能出现这种情况的
//因为一旦出现，JPivot会自动转化成加一个CurrentMember函数
//如：[Time].Children会自动转变成[Time].CurrentMember.Children
bool isall = false;
if (size == 1)
{
cout<<"error! invalid using of Children"<<endl;
}
else
{
vector<Level*> levelVec = pHie->getLeveles();
Member* mem = levelVec.at(0)->getMember(theVector.at(1), 0);
for (int i = 1; i < size-1; i++)
{
mem = levelVec.at(i)->getMember(theVector.at(i+1), mem);
}
vector<Member*> memVec = mem->getChildrenMember();
vector<Member*>::iterator memIterator;
QueryMember * ptr;
for (memIterator = memVec.begin(); memIterator < memVec.end(); memIterator++)
{
ptr = DwMemToQryMem(*memIterator,dimName,hieName);
QmemVector.push_back(ptr);
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
break;
}
//下一个函数起点
case Siblings:
if(size >= 2){
vector<Level*> levelVec = pHie->getLeveles();
Level *pLevel = levelVec.at(0);
Member* temp = levelVec.at(0)->getMember(theVector.at(1), 0);
for (int i = 1; i < size-1; i++)
{
temp = levelVec.at(i)->getMember(theVector.at(i+1), temp);
pLevel = levelVec.at(i); //兄弟成员所在的level
}
Member* pMem = temp->getParent();
vector<Member *> memVec;
if(!pMem) //不存在父成员,如Time.1998
{
memVec = pLevel->getMembers();
}
else
{
memVec = pMem->getChildrenMember();
}
vector<Member *>::iterator memIterator;
QueryMember *ptr;
for(memIterator = memVec.begin();memIterator != memVec.end();memIterator++)
{
ptr = DwMemToQryMem(*memIterator,dimName,hieName);
QmemVector.push_back(ptr);
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
else
{
cout<<"Siblings funtion error,too less member"<<endl;
return 0;
}
break;
case Descendants:
{
Level *ancLevel; //先代成员所在的level
Level *decLevel; //后代成员所在的level
vector<Level*> levelVec = pHie->getLeveles();
Member* ancMember = levelVec.at(0)->getMember(theVector.at(1), 0);
//定位目标成员
for (int i = 1; i < size-1; i++)
{
ancMember = levelVec.at(i)->getMember(theVector.at(i+1), ancMember);
ancLevel = levelVec.at(i);
}
if(param->getHasIntParam() || param->getHasStrParam())
{
if(param->getHasIntParam()) //如果包含数字型参数
{
int num = param->getIntParam();
decLevel = ancLevel;
if(num>0)
{
// 定位目标级别
for(int j=0;j<num;j++)
{
decLevel = decLevel ->getChildLevel();
assert(decLevel); //不存在该级别
}
}
}
if(param->getHasStrParam()) //如果包含字符型参数
{
char *str = param->getStrParam();
// 定位目标级别
decLevel = pHie->getLevel(str);
assert(decLevel); //不存在该级别
}
vector<Member *> _mem = decLevel->getMembers();
vector<QueryMember*> QmemVector;
QueryMember* ancMem = DwMemToQryMem(ancMember,dimName,hieName);
QueryMember* decMem;
for(int i = 0; i< _mem.size(); i++)
{
decMem = DwMemToQryMem(_mem.at(i),dimName,hieName);
//此处仍可改进，没必要遍历级别上的所有成员
if(isAncestor(ancMem, decMem))
{
QmemVector.push_back(decMem);
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
}
}
else //如果不含参数
{
getDescendants(ancMember,dimName,hieName,QtupleVector);
}
pHie->CleanMembers();
return QtupleVector;
}
break;
case Ascendants:
{
vector<Level*> levelVec = pHie->getLeveles();
Member* decMember = levelVec.at(0)->getMember(theVector.at(1), 0);
//定位目标成员
for (int i = 1; i < size-1; i++)
{
decMember = levelVec.at(i)->getMember(theVector.at(i+1), decMember);
assert(decMember);
}
vector<QueryMember*> QmemVector;
QueryMember * ancQryMem;
Member* ancMember = decMember ;
while(ancMember)
{
ancQryMem = DwMemToQryMem(ancMember,dimName,hieName);
QmemVector.push_back(ancQryMem);
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
ancMember = ancMember->getParent();
}
pHie->CleanMembers();
return QtupleVector;
}
break;
}
}
void HierarchyUtils<Scalar, LocalOrdinal, GlobalOrdinal, Node>::AddNonSerializableDataToHierarchy(HierarchyManager& HM, Hierarchy& H, const ParameterList& paramList) {
for (ParameterList::ConstIterator it = paramList.begin(); it != paramList.end(); it++) {
const std::string& levelName = it->first;
// Check for mach of the form "level X" where X is a positive integer
if (paramList.isSublist(levelName) && levelName.find("level ") == 0 && levelName.size() > 6) {
int levelID = strtol(levelName.substr(6).c_str(), 0, 0);
if (levelID > 0)
{
// Do enough level adding so we can be sure to add the data to the right place
for (int i = H.GetNumLevels(); i <= levelID; i++)
H.AddNewLevel();
}
RCP<Level> level = H.GetLevel(levelID);
RCP<FactoryManager> M = Teuchos::rcp_dynamic_cast<FactoryManager>(HM.GetFactoryManager(levelID));
TEUCHOS_TEST_FOR_EXCEPTION(M.is_null(), Exceptions::InvalidArgument, "MueLu::Utils::AddNonSerializableDataToHierarchy: cannot get FactoryManager");
// Grab the level sublist & loop over parameters
const ParameterList& levelList = paramList.sublist(levelName);
for (ParameterList::ConstIterator it2 = levelList.begin(); it2 != levelList.end(); it2++) {
const std::string& name = it2->first;
TEUCHOS_TEST_FOR_EXCEPTION(name != "A" && name != "P" && name != "R" &&
name != "Nullspace" && name != "Coordinates" &&
!IsParamMuemexVariable(name), Exceptions::InvalidArgument,
"MueLu::Utils::AddNonSerializableDataToHierarchy: parameter list contains unknown data type");
if (name == "A") {
level->Set(name, Teuchos::getValue<RCP<Matrix > > (it2->second),NoFactory::get());
M->SetFactory(name, NoFactory::getRCP()); // TAW: not sure about this: be aware that this affects all levels
// However, A is accessible through NoFactory anyway, so it should
// be fine here.
}
else if( name == "P" || name == "R") {
level->AddKeepFlag(name,NoFactory::get(),MueLu::UserData);
level->Set(name, Teuchos::getValue<RCP<Matrix > > (it2->second), M->GetFactory(name).get());
}
else if (name == "Nullspace")
{
level->AddKeepFlag(name,NoFactory::get(),MueLu::UserData);
level->Set(name, Teuchos::getValue<RCP<MultiVector > >(it2->second), NoFactory::get());
//M->SetFactory(name, NoFactory::getRCP()); // TAW: generally it is a bad idea to overwrite the factory manager data here
// One should do this only in very special cases
}
else if(name == "Coordinates") //Scalar of Coordinates MV is always double
{
level->AddKeepFlag(name,NoFactory::get(),MueLu::UserData);
level->Set(name, Teuchos::getValue<RCP<Xpetra::MultiVector<double, LocalOrdinal, GlobalOrdinal, Node> > >(it2->second), NoFactory::get());
//M->SetFactory(name, NoFactory::getRCP()); // TAW: generally it is a bad idea to overwrite the factory manager data here
}
#ifdef HAVE_MUELU_MATLAB
else
{
//Custom variable for Muemex
size_t typeNameStart = name.find_first_not_of(' ');
size_t typeNameEnd = name.find(' ', typeNameStart);
std::string typeName = name.substr(typeNameStart, typeNameEnd - typeNameStart);
std::transform(typeName.begin(), typeName.end(), typeName.begin(), ::tolower);
level->AddKeepFlag(name, NoFactory::get(), MueLu::UserData);
if(typeName == "matrix")
level->Set(name, Teuchos::getValue<RCP<Matrix> >(it2->second), NoFactory::get());
else if(typeName == "multivector")
level->Set(name, Teuchos::getValue<RCP<MultiVector> >(it2->second), NoFactory::get());
else if(typeName == "map")
level->Set(name, Teuchos::getValue<RCP<Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node> > >(it2->second), NoFactory::get());
else if(typeName == "ordinalvector")
level->Set(name, Teuchos::getValue<RCP<Xpetra::Vector<LocalOrdinal, LocalOrdinal, GlobalOrdinal, Node> > >(it2->second), NoFactory::get());
else if(typeName == "scalar")
level->Set(name, Teuchos::getValue<Scalar>(it2->second), NoFactory::get());
else if(typeName == "double")
level->Set(name, Teuchos::getValue<double>(it2->second), NoFactory::get());
else if(typeName == "complex")
level->Set(name, Teuchos::getValue<std::complex<double> >(it2->second), NoFactory::get());
else if(typeName == "int")
level->Set(name, Teuchos::getValue<int>(it2->second), NoFactory::get());
else if(typeName == "string")
level->Set(name, Teuchos::getValue<std::string>(it2->second), NoFactory::get());
}
#endif
}
}
}
}
core::RigidBody create_rigid_body(Hierarchy h) {
return create_rigid_body(Hierarchies(1,h), h->get_name()+" rigid body");
}
//---------------------------------------------------------
// Compute x-coordinates (LP-based approach) (for graphs)
//---------------------------------------------------------
void OptimalHierarchyLayout::computeXCoordinates(
const Hierarchy& H,
GraphCopyAttributes &AGC)
{
const GraphCopy &GC = H;
const int k = H.size();
//
// preprocessing: determine nodes that are considered as virtual
//
NodeArray<bool> isVirtual(GC);
int i;
for(i = 0; i < k; ++i)
{
const Level &L = H[i];
int last = -1;
for(int j = 0; j < L.size(); ++j)
{
node v = L[j];
if(H.isLongEdgeDummy(v) == true) {
isVirtual[v] = true;
node u = v->firstAdj()->theEdge()->target();
if(u == v) u = v->lastAdj()->theEdge()->target();
if(H.isLongEdgeDummy(u) == true) {
int down = H.pos(u);
if(last != -1 && last > down) {
isVirtual[v] = false;
} else {
last = down;
}
}
} else
isVirtual[v] = false;
}
}
//
// determine variables of LP
//
int nSegments = 0; // number of vertical segments
int nRealVertices = 0; // number of real vertices
int nEdges = 0; // number of edges not in vertical segments
int nBalanced = 0; // number of real vertices with deg > 1 for which
// balancing constraints may be applied
NodeArray<int> vIndex(GC,-1); // for real node: index of x[v]
// for dummy: index of corresponding segment
NodeArray<int> bIndex(GC,-1); // (relative) index of b[v]
EdgeArray<int> eIndex(GC,-1); // for edge not in vertical segment:
// its index
Array<int> count(GC.numberOfEdges()); // counts the number of dummy vertices
// in corresponding segment that are not at
// position 0
for(i = 0; i < k; ++i)
{
const Level &L = H[i];
for(int j = 0; j < L.size(); ++j) {
node v = L[j];
if(isVirtual[v] == true)
continue;
// we've found a real vertex
vIndex[v] = nRealVertices++;
if(v->degree() > 1)
bIndex[v] = nBalanced++;
// consider all outgoing edges
edge e;
forall_adj_edges(e,v) {
node w = e->target();
if(w == v)
continue;
// we've found an edge not belonging to a vetical segment
eIndex[e] = nEdges++;
if(isVirtual[w] == false)
continue;
// we've found a vertical segment
count[nSegments] = 0;
do {
vIndex[w] = nSegments;
const int high = H[H.rank(w)].high();
if(high > 0) {
if (H.pos(w) == 0 || H.pos(w) == high)
++count[nSegments];
else
count[nSegments] += 2;
}
// next edge / dummy in segment
e = e->adjTarget()->cyclicSucc()->theEdge();
w = e->target();
} while(isVirtual[w]);
// edge following vertical segment
eIndex[e] = nEdges++;
++nSegments;
}
}
}
//Called whenever a key on the keyboard was pressed.
//The key is given by the ''key'' parameter, which is in ASCII.
//It's often a good idea to have the escape key (ASCII value 27) call glutLeaveMainLoop() to
//exit the program.
void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case 27:
glutLeaveMainLoop();
return;
case 'a': g_armature.AdjBase(true); break;
case 'd': g_armature.AdjBase(false); break;
case 'w': g_armature.AdjUpperArm(false); break;
case 's': g_armature.AdjUpperArm(true); break;
case 'r': g_armature.AdjLowerArm(false); break;
case 'f': g_armature.AdjLowerArm(true); break;
case 't': g_armature.AdjWristPitch(false); break;
case 'g': g_armature.AdjWristPitch(true); break;
case 'z': g_armature.AdjWristRoll(true); break;
case 'c': g_armature.AdjWristRoll(false); break;
case 'q': g_armature.AdjFingerOpen(true); break;
case 'e': g_armature.AdjFingerOpen(false); break;
case 32: g_armature.WritePose(); break;
}
}
