Something went wrong on our end
-
Marco Biasini authoredMarco Biasini authored
export_entity.cc 12.47 KiB
//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2011 by the OpenStructure authors
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 3.0 of the License, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//------------------------------------------------------------------------------
#include <boost/python.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
using namespace boost::python;
#include <ost/gfx/entity.hh>
using namespace ost;
using namespace ost::gfx;
#include <ost/export_helper/pair_to_tuple_conv.hh>
#include "color_by_def.hh"
namespace {
void color_by_chain_01(Entity* e)
{
e->ColorByChain();
}
void color_by_chain_02(Entity* e, const String& selection)
{
e->ColorByChain(selection);
}
void color_by_element_01(Entity* e)
{
e->ColorByElement();
}
void color_by_element_02(Entity* e, const String& selection)
{
e->ColorByElement(selection);
}
void color_by_01(Entity* e,
const String& prop,
const Gradient& gradient,
float minv,float maxv,
mol::Prop::Level hint)
{
e->ColorBy(prop,gradient,minv,maxv,hint);
}
void color_by_02(Entity* e,
const String& prop,
const Gradient& gradient,
float minv,float maxv)
{
e->ColorBy(prop,gradient,minv,maxv);
}
void color_by_03(Entity* e,
const String& prop,
const Gradient& gradient, mol::Prop::Level hint)
{
e->ColorBy(prop,gradient,hint);
}
void color_by_04(Entity* e,
const String& prop,
const Gradient& gradient)
{
e->ColorBy(prop,gradient);
}
void color_by_05(Entity* e,
const String& prop,
const Color& c1, const Color& c2,
float minv,float maxv,
mol::Prop::Level hint)
{
e->ColorBy(prop,c1,c2,minv,maxv,hint);
}
void color_by_06(Entity* e,
const String& prop,
const Color& c1, const Color& c2,
float minv,float maxv)
{
e->ColorBy(prop,c1,c2,minv,maxv);
}
void color_by_07(Entity* e,
const String& prop,
const Color& c1, const Color& c2,
mol::Prop::Level hint)
{
e->ColorBy(prop,c1,c2,hint);
}
void color_by_08(Entity* e,
const String& prop,
const Color& c1, const Color& c2)
{
e->ColorBy(prop,c1,c2);
}
void color_by_09(Entity* e,
const String& prop,
const Gradient& gradient,
const String& selection)
{
e->ColorBy(prop,gradient,selection);
}
void color_by_10(Entity* e,
const String& prop,
const Gradient& gradient,
float minv, float maxv,
bool clamp)
{
e->ColorBy(prop,gradient,minv,maxv,clamp);
}
// temporary, see comment in gfx/entity.hh
void detail_color_by_02(Entity* e,
const String& prop,
const Gradient& gradient,
float minv,float maxv)
{
e->DetailColorBy(prop,gradient,minv,maxv);
}
void radius_by_01(Entity* e,
const String& prop,
float rmin,float rmax,
float minv,float maxv,
mol::Prop::Level hint)
{
e->RadiusBy(prop,rmin,rmax,minv,maxv,hint);
}
void radius_by_02(Entity* e,
const String& prop,
float rmin,float rmax,
float minv,float maxv)
{
e->RadiusBy(prop,rmin,rmax,minv,maxv);
}
void radius_by_03(Entity* e,
const String& prop,
float rmin,float rmax,
mol::Prop::Level hint)
{
e->RadiusBy(prop,rmin,rmax,hint);
}
void radius_by_04(Entity* e,
const String& prop,
float rmin,float rmax)
{
e->RadiusBy(prop,rmin,rmax);
}
void ent_set_color1(Entity* e, const Color& c) {
e->SetColor(c);
}
void ent_set_color2(Entity* e, const Color& c, const String& s) {
e->SetColor(c,s);
}
void ent_apply_11(Entity* e, UniformColorOp& uco, bool store){
e->Apply(uco,store);
}
void ent_apply_12(Entity* e, UniformColorOp& uco){
e->Apply(uco);
}
void ent_apply_21(Entity* e, ByElementColorOp& beco, bool store){
e->Apply(beco,store);
}
void ent_apply_22(Entity* e, ByElementColorOp& beco){
e->Apply(beco);
}
void ent_apply_31(Entity* e, ByChainColorOp& beco, bool store){
e->Apply(beco,store);
}
void ent_apply_32(Entity* e, ByChainColorOp& beco){
e->Apply(beco);
}
void ent_apply_41(Entity* e, EntityViewColorOp& evco, bool store){
e->Apply(evco,store);
}
void ent_apply_42(Entity* e, EntityViewColorOp& evco){
e->Apply(evco);
}
void ent_apply_51(Entity* e, GradientLevelColorOp& glco, bool store){
e->Apply(glco,store);
}
void ent_apply_52(Entity* e, GradientLevelColorOp& glco){
e->Apply(glco);
}
#if OST_IMG_ENABLED
void ent_apply_61(Entity* e, MapHandleColorOp& mhco, bool store){
e->Apply(mhco,store);
}
void ent_apply_62(Entity* e, MapHandleColorOp& mhco){
e->Apply(mhco);
}
#endif //OST_IMG_ENABLED
RenderOptionsPtr ent_sline_opts(Entity* ent)
{
return ent->GetOptions(RenderMode::SLINE);
}
void (Entity::*set_rm1)(RenderMode::Type, const mol::EntityView&, bool)=&Entity::SetRenderMode;
void (Entity::*set_rm3)(RenderMode::Type, const String&, bool)=&Entity::SetRenderMode;
void (Entity::*set_rm2)(RenderMode::Type)=&Entity::SetRenderMode;
void (Entity::*set_vis1)(const mol::EntityView&, bool)=&Entity::SetVisible;
void (Entity::*set_vis2)(const String&, bool)=&Entity::SetVisible;
RenderOptionsPtr ent_trace_opts(Entity* ent)
{
return ent->GetOptions(RenderMode::TRACE);
}
RenderOptionsPtr ent_simple_opts(Entity* ent)
{
return ent->GetOptions(RenderMode::SIMPLE);
}
RenderOptionsPtr ent_custom_opts(Entity* ent)
{
return ent->GetOptions(RenderMode::CUSTOM);
}
RenderOptionsPtr ent_tube_opts(Entity* ent)
{
return ent->GetOptions(RenderMode::TUBE);
}
RenderOptionsPtr ent_hsc_opts(Entity* ent)
{
return ent->GetOptions(RenderMode::HSC);
}
RenderOptionsPtr ent_cpk_opts(Entity* ent)
{
return ent->GetOptions(RenderMode::CPK);
}
void set_query(Entity* e, object o)
{
LOG_WARNING("SetQuery is deprecated, use source property instead");
if(o==object()) {
e->SetQuery(mol::Query());
return;
}
extract<String> str(o);
if(str.check()) { e->SetQuery(mol::Query(str()));
return;
}
extract<mol::Query> qry(o);
if(qry.check()) {
e->SetQuery(qry());
return;
}
throw Error("expected string or mol::Query as parameter");
}
RenderOptionsPtr ent_ltrace_opts(Entity* ent)
{
return ent->GetOptions(RenderMode::LINE_TRACE);
}
void set_selection(Entity* ent, object sel)
{
object none;
if (sel==none) {
ent->SetSelection(ent->GetView().CreateEmptyView());
return;
}
try {
String sel_string=extract<String>(sel);
ent->SetSelection(ent->GetView().Select(sel_string));
} catch (error_already_set& e) {
PyErr_Clear();
mol::EntityView view=extract<mol::EntityView>(sel);
ent->SetSelection(view);
}
}
}
void export_Entity()
{
void (Entity::*reset1)(const mol::EntityHandle&) = &Entity::Reset;
void (Entity::*reset2)(const mol::EntityHandle&, const mol::Query&) = &Entity::Reset;
void (Entity::*reset3)(const mol::EntityHandle&, const mol::Query&, mol::QueryFlags) = &Entity::Reset;
void (Entity::*reset4)(const mol::EntityView&) = &Entity::Reset;
class_<Entity, boost::shared_ptr<Entity>, bases<GfxObj>, boost::noncopyable>("Entity", init<const String&, const mol:: EntityHandle&, optional<const mol:: Query&, mol::QueryFlags> >())
.def(init<const String&, RenderMode::Type, const mol::EntityHandle&, optional<const mol::Query&, mol::QueryFlags> >())
.def(init<const String&, const mol::EntityView&>())
.def(init<const String&, RenderMode::Type, const mol::EntityView&>())
.def("_reset1",reset1)
.def("_reset2",reset2)
.def("_reset3",reset3)
.def("_reset4",reset4)
.def("SetColor",ent_set_color1)
.def("SetColor",ent_set_color2)
.def("SetDetailColor", &Entity::SetDetailColor, arg("sel")=String(""))
.def("SetColorForAtom", &Entity::SetColorForAtom)
.def("Rebuild", &Entity::Rebuild)
.def("UpdatePositions",&Entity::UpdatePositions)
.def("BlurSnapshot", &Entity::BlurSnapshot)
.def("SetBlurFactors",&Entity::SetBlurFactors)
.def("SetBlur",&Entity::SetBlur)
.def("GetBoundingBox",&Entity::GetBoundingBox)
.def("SetSelection",&Entity::SetSelection)
.def("GetSelection",&Entity::GetSelection)
.add_property("selection", &Entity::GetSelection,
&set_selection)
.def("GetView", &Entity::GetView)
.add_property("view",&Entity::GetView)
.def("UpdateView", &Entity::UpdateView)
.def("SetQuery", set_query) .def("SetQueryView",&Entity::SetQueryView)
.def("GetQueryView",&Entity::GetQueryView)
.add_property("query_view",&Entity::GetQueryView,&Entity::SetQueryView)
.def("GetRenderModeName", &Entity::GetRenderModeName)
.def("GetNotEmptyRenderModes", &Entity::GetNotEmptyRenderModes)
.def("SetRenderMode", set_rm1, (arg("mode"), arg("view"), arg("keep")=false))
.def("SetRenderMode", set_rm2)
.def("SetRenderMode", set_rm3, (arg("mode"), arg("sel"), arg("keep")=false))
.def("SetEnableRenderMode", &Entity::SetEnableRenderMode)
.def("IsRenderModeEnabled", &Entity::IsRenderModeEnabled)
.def("SetVisible", set_vis1, (arg("view"), arg("flag")=true))
.def("SetVisible", set_vis2, (arg("sel"), arg("flag")=true))
.def("ColorBy", color_by_10) // this line must be before color_by_01 because
// of boost python overload resolution
.def("ColorBy", color_by_01)
.def("ColorBy", color_by_02)
.def("ColorBy", color_by_03)
.def("ColorBy", color_by_04)
.def("ColorBy", color_by_05)
.def("ColorBy", color_by_06)
.def("ColorBy", color_by_07)
.def("ColorBy", color_by_08)
.def("ColorBy", color_by_09)
.def("DetailColorBy", detail_color_by_02)
COLOR_BY_DEF()
.def("RadiusBy", radius_by_01)
.def("RadiusBy", radius_by_02)
.def("RadiusBy", radius_by_03)
.def("RadiusBy", radius_by_04)
.def("ResetRadiusBy", &Entity::ResetRadiusBy)
.def("PickAtom", &Entity::PickAtom)
.def("PickBond", &Entity::PickBond)
.def("ColorByElement", color_by_element_01)
.def("ColorByElement", color_by_element_02)
.def("ColorByChain", color_by_chain_01)
.def("ColorByChain", color_by_chain_02)
.def("CleanColorOps", &Entity::CleanColorOps)
.def("ReapplyColorOps", &Entity::ReapplyColorOps)
.def("GetOptions", &Entity::GetOptions)
.add_property("sline_options", &ent_sline_opts)
.add_property("simple_options", &ent_simple_opts)
.add_property("tube_options", &ent_tube_opts)
.add_property("custom_options", &ent_custom_opts)
.add_property("cartoon_options", &ent_hsc_opts)
.add_property("cpk_options", &ent_cpk_opts)
.add_property("trace_options", &ent_trace_opts)
.add_property("line_trace_options", &ent_ltrace_opts)
.def("ApplyOptions", &Entity::ApplyOptions)
.def("SetOptions", &Entity::SetOptions)
.def("Apply",&ent_apply_11)
.def("Apply",&ent_apply_12)
.def("Apply",&ent_apply_21)
.def("Apply",&ent_apply_22)
.def("Apply",&ent_apply_31)
.def("Apply",&ent_apply_32)
.def("Apply",&ent_apply_41)
.def("Apply",&ent_apply_42)
.def("Apply",&ent_apply_51)
.def("Apply",&ent_apply_52)
#if OST_IMG_ENABLED
.def("Apply",&ent_apply_61)
.def("Apply",&ent_apply_62)
#endif //OST_IMG_ENABLED
.add_property("seq_hack",&Entity::GetSeqHack,&Entity::SetSeqHack)
;
//register_ptr_to_python<EntityP>();
to_python_converter<std::pair<GfxObjP, mol::AtomHandle>,
PairToTupleConverter<GfxObjP, mol::AtomHandle> >();
class_<RenderModeTypes>("RenderModeTypes", init<>())
.def(vector_indexing_suite<RenderModeTypes, true >());
}