source: src/Actions/FillAction/FillSphericalSurfaceAction.cpp@ 50c35d

/*
 * Project: MoleCuilder
 * Description: creates and alters molecular systems
 * Copyright (C)  2010-2012 University of Bonn. All rights reserved.
 * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
 */

/*
 * FillSphericalSurfaceAction.cpp
 *
 *  Created on: Mar 29, 2012
 *      Author: heber, bollerhe
 */

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "CodePatterns/MemDebug.hpp"

#include "Atom/atom.hpp"
#include "Atom/CopyAtoms/CopyAtoms_Simple.hpp"
#include "CodePatterns/Log.hpp"
#include "Filling/Cluster.hpp"
#include "Filling/Filler.hpp"
#include "Filling/Inserter/Inserter.hpp"
#include "Filling/Inserter/SimpleInserter.hpp"
#include "Filling/Mesh/MeshAdaptor.hpp"
#include "Filling/Predicates/IsVoidNode_FillPredicate.hpp"
#include "Shapes/BaseShapes.hpp"
#include "World.hpp"


#include <algorithm>
#include <boost/foreach.hpp>
#include <boost/function.hpp>
#include <iostream>
#include <string>
#include <vector>

#include "Actions/FillAction/FillSphericalSurfaceAction.hpp"

using namespace MoleCuilder;

// and construct the stuff
#include "FillSphericalSurfaceAction.def"
#include "Action_impl_pre.hpp"
/** =========== define the function ====================== */
Action::state_ptr FillSphericalSurfaceAction::performCall() {
  typedef std::vector<atom*> AtomVector;

  // obtain information
  getParametersfromValueStorage();

  // check for selected atoms
  std::vector<atom *> atoms(World::getInstance().getSelectedAtoms());
  if (atoms.size() == 0) {
    ELOG(1, "There are no atoms selected.");
    return Action::failure;
  }
  AtomIdSet atomIds;
  BOOST_FOREACH(atom * const _atom, atoms) {
    atomIds.insert( _atom );
  }

  // create predicate, mesh, and filler
  bool successflag = false;
  {
    FillPredicate *voidnode_predicate = new FillPredicate(
        IsVoidNode_FillPredicate(
            Sphere(zeroVec, params.mindistance)
            )
        );
    Shape s = Sphere(params.center, params.radius);
    boost::function<const NodeSet ()> func = 
        boost::bind(&Shape::getHomogeneousPointsOnSurface, boost::ref(s), params.N);
    Mesh *mesh = new MeshAdaptor(func);
    Inserter *inserter = new Inserter(
        Inserter::impl_ptr(new SimpleInserter));

    // fill
    {
      Filler *fillerFunction = new Filler(*mesh, *voidnode_predicate, *inserter);
      ClusterInterface::Cluster_impl cluster( new Cluster( atomIds.getAtomIds(), Sphere()) ); //TODO: calculate true bounding box of atomIds
      CopyAtoms_Simple copyMethod;
      successflag = (*fillerFunction)(copyMethod, cluster);
      delete fillerFunction;
    }

    // remove
    delete mesh;
    delete inserter;
    delete voidnode_predicate;
  }

  if (successflag)
    return Action::success;
  else
    return Action::failure;
}

Action::state_ptr FillSphericalSurfaceAction::performUndo(Action::state_ptr _state) {
  return Action::failure;
}

Action::state_ptr FillSphericalSurfaceAction::performRedo(Action::state_ptr _state){
  return Action::failure;
}

bool FillSphericalSurfaceAction::canUndo() {
  return false;
}

bool FillSphericalSurfaceAction::shouldUndo() {
  return false;
}
/** =========== end of function ====================== */