C++ (Cpp) MasksManagerPtr Examples

Example #1

File: project.cpp Project: salilab/imp

void get_projection(em2d::Image *img, const ParticlesTemp &ps,
                    const RegistrationResult &reg,
                    const ProjectingOptions &options, MasksManagerPtr masks,
                    String name) {
  IMP_LOG_VERBOSE("Generating projection in a em2d::Image" << std::endl);

  if (masks == MasksManagerPtr()) {
    masks = MasksManagerPtr(
        new MasksManager(options.resolution, options.pixel_size));
    masks->create_masks(ps);
    IMP_LOG_VERBOSE("Masks generated from get_projection()" << std::endl);
  }
  algebra::Vector3D translation = options.pixel_size * reg.get_shift_3d();
  algebra::Rotation3D R = reg.get_rotation();

  do_project_particles(ps, img->get_data(), R, translation, options, masks);
  if (options.normalize) em2d::do_normalize(img, true);
  reg.set_in_image(img->get_header());
  img->get_header().set_object_pixel_size(options.pixel_size);
  if (options.save_images) {
    if (name.empty()) {
      IMP_THROW("get_projection: File name string is empty ", IOException);
    }
    if (options.srw == Pointer<ImageReaderWriter>()) {
      IMP_THROW(
          "The options class does not have an "
          "ImageReaderWriter assigned. Create an ImageReaderWriter "
          "and assigned to the srw member of ProjectingOptions.",
          IOException);
    }
    img->write(name, options.srw);
  }
}

Example #2

File: Fine2DRegistrationRestraint.cpp Project: j-ma-bu-l-l-ock/imp

void Fine2DRegistrationRestraint::setup(
    ParticlesTemp &ps, const ProjectingParameters &params,
    Model *scoring_model,
    //                       ScoreFunctionPtr score_function,
    ScoreFunction *score_function, MasksManagerPtr masks) {

  IMP_LOG_TERSE("Initializing Fine2DRegistrationRestraint" << std::endl);
  ps_ = ps;
  params_ = params;
  // Generate all the projection masks for the structure
  if (masks == MasksManagerPtr()) {
    // Create the masks
    masks_ =
        MasksManagerPtr(new MasksManager(params.resolution, params.pixel_size));
    masks_->create_masks(ps);
    IMP_LOG_VERBOSE("Created " << masks_->get_number_of_masks()
                               << " masks withing Fine2DRegistrationRestraint "
                               << std::endl);
  } else {
    masks_ = masks;
    IMP_LOG_VERBOSE("masks given to Fine2DRegistrationRestraint " << std::endl);
  }
  // Create a particle for the projection parameters to be optimized
  subj_params_particle_ = new Particle(scoring_model);
  PP_ = ProjectionParameters::setup_particle(subj_params_particle_);
  PP_.set_parameters_optimized(true);
  // Add an score state to the model

  IMP_NEW(ProjectionParametersScoreState, pp_score_state,
          (subj_params_particle_));
  scoring_model->add_score_state(pp_score_state);

  score_function_ = score_function;
}

Example #3

File: project.cpp Project: salilab/imp

void do_project_particles(const ParticlesTemp &ps, cv::Mat &m2,
                          const algebra::Rotation3D &R,
                          const algebra::Vector3D &translation,
                          const ProjectingOptions &options,
                          MasksManagerPtr masks) {
  IMP_LOG_VERBOSE("Projecting particles" << std::endl);
  if (m2.empty()) {
    IMP_THROW("Cannot project on a empty matrix", ValueException);
  }
  if (masks == MasksManagerPtr()) {
    // Create the masks
    masks = MasksManagerPtr(
        new MasksManager(options.resolution, options.pixel_size));
    masks->create_masks(ps);
  }
  // Centroid
  unsigned long n_particles = ps.size();
  // core::XYZRsTemp xyzrs(ps);
  core::XYZRs xyzrs(ps);
  algebra::Vector3D centroid = core::get_centroid(xyzrs);

  // clear data before creating a new projection
  if (options.clear_matrix_before_projecting) m2.setTo(0.0);
  // Project
  double invp = 1.0 / options.pixel_size;

  for (unsigned long i = 0; i < n_particles; i++) {
    // Coordinates respect to the centroid
    algebra::Vector3D p = xyzrs[i].get_coordinates() - centroid;
    // Pixel after transformation to project in Z axis
    // Not necessary to compute pz, is going to be ignored
    double pix_x = invp * (R.get_rotated_one_coordinate(p, 0) + translation[0]);
    double pix_y = invp * (R.get_rotated_one_coordinate(p, 1) + translation[1]);

    IMP_USAGE_CHECK(!IMP::isnan(pix_x) || !IMP::isnan(pix_y),
                    "do_project_particles: "
                        << n_particles << " resolution " << options.resolution
                        << " pixel size " << options.pixel_size << std::endl);

    // Apply mask
    ProjectionMaskPtr mask = masks->find_mask(atom::Mass(ps[i]).get_mass());
    algebra::Vector2D pix(pix_x, pix_y);
    mask->apply(m2, pix);
  }
  IMP_LOG_VERBOSE("END of do_project_particles" << std::endl);
}

Example #4

File: CollisionCrossSection.cpp Project: salilab/imp

IMPEM2D_BEGIN_NAMESPACE

CollisionCrossSection::CollisionCrossSection(unsigned int n_projections,
                                             double resolution,
                                             double pixel_size,
                                             double projection_image_size)
    : Object("CollisionCrossSection%1%"),
      n_projections_(n_projections),
      resolution_(resolution),
      pixel_size_(pixel_size),
      img_size_(projection_image_size),
      particles_set_(false) {
  regs_ = em2d::get_evenly_distributed_registration_results(n_projections_);
  average_projection_.create(img_size_, img_size_, CV_64FC1);
  masks_manager_ = MasksManagerPtr(new MasksManager);
  masks_manager_->setup_kernel(resolution_, pixel_size_);
}