def main(args):
if args.verbosity > 0:
print("input file: {}".format(args.input_file))
print("output file: {}".format(args.output_file))
if args.verbosity == 2:
print("dimensions: {}".format(args.dimensions))
print("renderer: {}".format(args.renderer))
print("particle size: {}".format(args.particle_size))
if args.renderer == 'tachyon':
renderer = TachyonRenderer()
elif args.renderer == 'opengl':
renderer = OpenGLRenderer()
else:
raise ValueError("{} is not a valid renderer".format(args.renderer))
node = import_file(args.input_file, multiple_frames=True)
node.add_to_scene()
vp = dataset.viewports.viewports[args.viewport]
if args.output_ext in MOVIE_TYPES and args.frames_per_second is not None:
dataset.anim.frames_per_second = args.frames_per_second
node.compute()
if args.overlay_frame_num == True:
overlay = TextLabelOverlay(
text='[SourceFrame]',
alignment=QtCore.Qt.AlignRight ^ QtCore.Qt.AlignBottom,
# offset_y = 0.1,
font_size=0.05,
text_color=(0, 0, 0),
)
vp.overlays.append(overlay)
vp.zoom_all()
for t in node.output.particle_properties.particle_type.type_list:
t.radius = args.particle_size
os.makedirs(os.path.dirname(args.output_file), exist_ok=True)
for i in range(len(args.custom_range)):
if args.custom_range[i] < 0:
args.custom_range[i] += node.source.num_frames
if args.output_ext in MOVIE_TYPES:
range_opt = RenderSettings.Range.CUSTOM_INTERVAL
elif args.output_ext in IMAGE_TYPES:
dataset.anim.current_frame = args.custom_range[0]
range_opt = RenderSettings.Range.CURRENT_FRAME
settings = RenderSettings(
filename=args.output_file,
size=args.dimensions,
range=range_opt,
custom_range=args.custom_range,
renderer=renderer,
)
if args.output_ext in MOVIE_TYPES:
settings.everyNthFrame = args.every_nth_frame
vp.render(settings)
def main(pdb_path, png_path):
node = import_file(pdb_path)
node.add_to_scene()
vp = dataset.viewports.active_vp
# node.modifiers.append(SelectExpressionModifier(expression = 'Position.X < Position.Y'))
node.modifiers.append(SliceModifier(distance=0, normal=(1, -1, 0)))
node.compute()
particle_types = node.output.particle_properties.particle_type
particle_types.get_type_by_name('H').color = (1, 0.5, 0.5)
particle_types.get_type_by_name('He').color = (0.5, 0.5, 1)
particle_types.get_type_by_name('O').color = (0.5, 0.5, 0.5)
os.makedirs(os.path.dirname(png_path), exist_ok=True)
settings = RenderSettings(
filename=png_path,
size=(800, 600),
renderer=TachyonRenderer(),
)
vp.render(settings)
def ovito_render():
"Render images using OVITO"
import ovito
from ovito.io import import_file
from ovito.vis import Viewport, RenderSettings, TachyonRenderer
from ovito.modifiers import ColorCodingModifier
from ovito.modifiers import PolyhedralTemplateMatchingModifier
pipeline = import_file("gcmc.out.xyz")
#ptm_modifier = PolyhedralTemplateMatchingModifier(
# color_by_type=True,
# rmsd_cutoff=0.3,
#)
#for structure_type in ['BCC', 'CUBIC_DIAMOND', 'FCC', 'GRAPHENE',
# 'HCP', 'HEX_DIAMOND', 'ICO', 'OTHER', 'SC']:
# structure_type = getattr(PolyhedralTemplateMatchingModifier.Type, structure_type)
# ptm_modifier.structures[structure_type].enabled = True
#pipeline.modifiers.append(ptm_modifier)
data_collection = pipeline.compute()
pipeline.add_to_scene()
renderer = TachyonRenderer(antialiasing_samples=32, )
vp = Viewport(type=Viewport.Type.Perspective, camera_dir=(2, 1, -1))
vp.zoom_all()
vp.camera_pos = np.asarray(vp.camera_pos) * np.array([0.8, 0.8, 0.75])
vp.render_image(
filename='sample.png',
size=(1000, 750),
frame=pipeline.source.num_frames - 1,
alpha=True,
renderer=renderer,
)
every_nth = pipeline.source.num_frames // 20
video = vp.render_anim(
filename='sample.gif',
size=(480, 320),
fps=5,
renderer=renderer,
every_nth=every_nth,
)
image = vp.render_image(size=(800, 600),
filename='img.png',
frame=pipeline.source.num_frames)
pipeline.remove_from_scene()
# color APB in bright green
pipeline.modifiers.append(ExpressionSelectionModifier(expression='FaultType == 1'))
pipeline.modifiers.append(ComputePropertyModifier(
output_property='Color',
expressions=['Color.G*' + str(bright), 'Color.B*' + str(bright), 'Color.R*' + str(bright)],
only_selected=True))
# color SISF in bright yellow
pipeline.modifiers.append(ExpressionSelectionModifier(expression='FaultType == 3'))
pipeline.modifiers.append(ComputePropertyModifier(
output_property='Color',
expressions=['Color.B*' + str(bright), 'Color.B*' + str(bright), 'Color.R*' + str(bright)],
only_selected=True))
data = pipeline.compute()
# remove dxa defect mesh
defect_mesh = data.surfaces['dxa-defect-mesh']
defect_mesh.vis.enabled = False
data.cell.vis.enabled = False
data.particles.bonds.vis.enabled = False
pipeline.add_to_scene()
data.particles.vis.enabled = True
tachyon = TachyonRenderer()
vp = Viewport(type=Viewport.Type.Ortho, camera_dir=(-1, 0.3, -0.2))
vp.zoom_all()
vp.render_image(size=(1600, 1200), filename=output_name + ".png", background=(0, 0, 0), renderer=tachyon)
print('----------job done!-------------')
def write(atoms,
filename,
bond_specs=None,
atom_style="molecular",
size=(640, 480),
camera_dir=(2, 1, -1),
viewport_type="perspective",
atom_radii=None):
"""Write atoms to lammps data file
:param atoms: The atoms object to write to file
:type atoms: ase.Atoms
:param filename: filename to write to. Can either have suffix `.data` or `.png`, in which case a Lammps data file or a png picture will be produced, respectively.
:type filename: str
:param bonds_spec: List of (element1, element2, cutoff)
:type bonds_spec: List of tuples
"""
import os
suffix = os.path.splitext(filename)[1]
if not suffix in [".data", ".png"]:
raise ValueError(f"Invalid file format {suffix}")
import tempfile
import os
from ase.formula import Formula
# Using tempfile and write + read rather than ovito's ase_to_ovito and back because the
# ordering of particle types for some (bug) reason becomes unpredictable
with tempfile.TemporaryDirectory() as tmp_dir:
symbols = list(Formula(atoms.get_chemical_formula()).count().keys())
symbols_dict = {}
for i, symbol in enumerate(symbols):
symbols_dict[symbol] = i + 1
atoms.write(os.path.join(tmp_dir, "tmp.data"),
format="lammps-data",
specorder=symbols)
from ovito.io import import_file, export_file
from ovito.modifiers import CreateBondsModifier
pipeline = import_file(os.path.join(tmp_dir, "tmp.data"))
types = pipeline.source.data.particles_.particle_types
for symbol, i in symbols_dict.items():
types.type_by_id(i).name = symbol
types.type_by_id(i).load_defaults()
if not atom_radii is None:
types = pipeline.source.data.particles.particle_types
for pair in atom_radii:
types.type_by_id(symbols_dict[pair[0]]).radius = pair[1]
# Accept a single tuple not contained in a list if there is only one bond type.
if not bond_specs is None:
bondsmodifier = CreateBondsModifier(
mode=CreateBondsModifier.Mode.Pairwise)
if not isinstance(bond_specs, list) and isinstance(
bond_specs, tuple):
bond_specs = [bond_specs]
for element in bond_specs:
bondsmodifier.set_pairwise_cutoff(symbols_dict[element[0]],
symbols_dict[element[1]],
element[2])
pipeline.modifiers.append(bondsmodifier)
pipeline.compute()
if suffix == ".data":
export_file(pipeline,
filename,
"lammps/data",
atom_style=atom_style)
elif suffix == ".png":
from ovito.vis import Viewport, TachyonRenderer, OpenGLRenderer
pipeline.add_to_scene()
if viewport_type == "perspective":
vp = Viewport(type=Viewport.Type.Perspective,
camera_dir=camera_dir)
elif viewport_type == "orthogonal":
vp = Viewport(type=Viewport.Type.Ortho, camera_dir=camera_dir)
else:
raise ValueError(
"viewport type has to be perspective or orthogonal")
vp.zoom_all(size=size)
vp.render_image(filename=filename,
size=size,
renderer=TachyonRenderer())
pipeline.remove_from_scene()
gbp=str(sys.argv[1])+'_gbp.png'
## using pipleline object
# pipeline = import_file('file.lmp')
pipeline = import_file(str(sys.argv[1])) #uses the second argument as file ip
## to get the sim cell dimensions
data=pipeline.compute()
dim=data.cell.matrix
lz=dim[2][2]
# print(lz)
pipeline.add_to_scene() ## updating pipeline
vp = Viewport(type = Viewport.Type.Left)
vp.zoom_all()
vp.render_image(filename=Leftv,
#size=(320, 240),
size=(640, 480),
renderer=TachyonRenderer())
slicegb = SliceModifier(distance=lz*0.5,
normal = (0,0,1),
slice_width = 0.3
)
pipeline.modifiers.append(slicegb)
vp = Viewport(type = Viewport.Type.Top)
vp.zoom_all()
vp.render_image(filename=gbp,
size=(640, 480),
renderer=TachyonRenderer())
from ovito.vis import RenderSettings, Viewport, TachyonRenderer
settings = RenderSettings(size=(320, 240),
filename="myfigure.png",
background_color=(0, 0, 0),
renderer=TachyonRenderer(shadows=False,
direct_light=False))
vp = Viewport(type=Viewport.Type.PERSPECTIVE, camera_dir=(-100, -50, -50))
vp.zoom_all()
vp.render(settings)
import ovito
settings = RenderSettings(size=(1280, 720),
filename='movie.mp4',
range=RenderSettings.Range.ANIMATION)
ovito.dataset.anim.frames_per_second = 30
settings = RenderSettings(size=(1280, 720),
filename='frame.png',
range=RenderSettings.Range.ANIMATION)
from ovito.io import import_file
from ovito.modifiers import SelectTypeModifier, DeleteSelectedModifier, AssignColorModifier
from ovito.vis import Viewport, TachyonRenderer
Renderer = TachyonRenderer(ambient_occlusion_brightness=0.6,
direct_light_intensity=0.7,
depth_of_field=True)
selector0 = SelectTypeModifier(types={0})
selector1 = SelectTypeModifier(types={1})
delector = DeleteSelectedModifier()
coloror = AssignColorModifier(color=(1.0, .9, 0.8))
rand = [(0.75, 10, 0.7), (0.75, 14, 0.3), (0.75, 14, 0.8), (0.75, 18, 0.5),
(0.75, 18, 0.55), (0.75, 18, 0.75), (0.75, 18, 0.8), (0.75, 22, 0.8),
(0.75, 26, 0.3), (0.75, 26, 0.4), (0.75, 26, 0.75), (0.75, 26, 0.8),
(0.75, 30, 0.6), (0.75, 34, 0.3), (0.75, 34, 0.4), (0.75, 34, 0.6),
(0.75, 42, 0.35), (0.5, 10, 0.8), (0.5, 14, 0.8), (0.5, 18, 0.8),
(0.5, 22, 0.3), (0.5, 22, 0.4), (0.5, 26, 0.2), (0.5, 26, 0.6),
(0.5, 34, 0.7), (0.5, 34, 0.25), (0.25, 26, 0.7), (0.25, 30, 0.8),
(0.25, 34, 0.8), (0.25, 42, 0.65), (0.25, 42, 0.8)]
def Render1(item, Renderer, selector0, delector):
pipeline = import_file('./../frac_' + str(item[0]) + '/m_' + str(item[1]) +
'/d_' + str(item[2]) + '/final_snapshot.xyz')
pipeline.modifiers.append(selector0)
pipeline.modifiers.append(delector)
pipeline.add_to_scene()
vis_element = pipeline.source.data.particles.vis
def show_ovito(particle,
cell,
outfile=None,
radius=0.35,
viewport=None,
callback=None,
tmpdir=None,
camera_dir=(0, 1, 0),
camera_pos=(0, -10, 0),
size=(640, 480),
zoom=True,
perspective=False):
"""
Render particle in cell using ovito
"""
import os
try:
from ovito.io import import_file
except ImportError:
_log.warning('install ovito to display the particles')
return
from ovito.vis import Viewport, TachyonRenderer
from ovito.vis import ParticlesVis
import tempfile
from atooms.core.utils import mkdir
# Make sure dirname exists
if outfile is not None:
mkdir(os.path.dirname(outfile))
# Get a temporary file to write the sample
fh = tempfile.NamedTemporaryFile('w',
dir=tmpdir,
suffix='.xyz',
delete=False)
tmp_file = fh.name
# Self-contained EXYZ dump (it is not clean to use trajectories here)
fh.write('{}\n'.format(len(particle)))
fh.write(
'Properties=species:S:1:pos:R:3 Lattice="{},0.,0.,0.,{},0.,0.,0.,{}"\n'
.format(*cell.side))
for p in particle:
fh.write('{} {} {} {}\n'.format(p.species, *p.position))
fh.close()
# Ovito stuff. Can be customized by client code.
pipeline = import_file(tmp_file)
# Ovito seems to ignore the lattice info of exyz file
# so we forcibly set the cell info here
pipeline.source.data.cell_[0, 0] = cell.side[0]
pipeline.source.data.cell_[1, 1] = cell.side[1]
pipeline.source.data.cell_[2, 2] = cell.side[2]
pipeline.source.data.cell_[:, 3] = -cell.side / 2
# Scale radius by default
vis_element = pipeline.source.data.particles.vis
vis_element.radius = radius
# Apply client code callback
if callback:
callback(pipeline)
pipeline.add_to_scene()
# Define viewport
if viewport:
vp = vieport
else:
if perspective:
vp = Viewport(type=Viewport.Type.Perspective,
camera_dir=camera_dir,
camera_pos=camera_pos)
else:
vp = Viewport(type=Viewport.Type.Ortho,
camera_dir=camera_dir,
camera_pos=camera_pos)
# Render
if zoom:
vp.zoom_all()
if outfile is None:
outfile = tmp_file + '.png'
vp.render_image(filename=outfile, size=size, renderer=TachyonRenderer())
# Scene is a singleton, so we must clear it
pipeline.remove_from_scene()
from atooms.core.utils import rmf
rmf(tmp_file)
# Try to display the image (e.g. in a jupyter notebook)
try:
from IPython.display import Image
return Image(outfile)
except ImportError:
return outfile