wolfhece 2.1.119__py3-none-any.whl → 2.1.120__py3-none-any.whl

wolfhece/PyVertexvectors.py

@@ -46,6 +46,7 @@ from .PyVertex import wolfvertex,getIfromRGB,getRGBfromI, cloud_vertices
 from .PyParams import Wolf_Param, Type_Param, new_json
 from .wolf_texture import Text_Image_Texture,Text_Infos
 from .drawing_obj import Element_To_Draw
+from .matplotlib_fig import Matplotlib_Figure as MplFig
 
 class Triangulation(Element_To_Draw):
     def __init__(self, fn='', pts=[], tri=[], idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False) -> None:
@@ -2626,6 +2627,83 @@ class vector:
 
         return fig,ax
 
+    def plot_linked_wx(self, fig:MplFig, linked_arrays:dict):
+        """
+        Graphique Matplolib de valeurs dans les matrices liées.
+
+        Version pour wxPython
+        """
+
+        colors=['red','blue','green']
+
+        exit=True
+        for curlabel, curarray in linked_arrays.items():
+            if curarray.plotted:
+                exit=False
+
+        if exit:
+            return
+
+        k=0
+
+        myls = self.asshapely_ls()
+        length = myls.length
+        tol=length/10.
+        fig.cur_ax.set_xlim(0-tol,length+tol)
+
+        zmin=99999.
+        zmax=-99999.
+        nullvalue = -99999
+
+        for curlabel, curarray in linked_arrays.items():
+            if curarray.plotted:
+
+                ds = curarray.get_dxdy_min()
+
+                nb = int(np.ceil(length/ds*2))
+
+                alls = np.linspace(0,int(length),nb)
+
+                pts = [myls.interpolate(curs) for curs in alls]
+
+                allz = np.asarray([curarray.get_value(curpt.x,curpt.y, nullvalue= nullvalue) for curpt in pts])
+
+                zmaxloc=np.max(allz[allz!=nullvalue])
+                zminloc=np.min(allz[allz!=nullvalue])
+
+                zmax=max(zmax,zmaxloc)
+                zmin=min(zmin,zminloc)
+
+                if np.max(allz)>nullvalue:
+                    # select parts
+                    if nullvalue in allz:
+                        # find all parts separated by nullvalue
+                        nulls = np.argwhere(allz==nullvalue)
+                        nulls = np.insert(nulls,0,-1)
+                        nulls = np.append(nulls,len(allz))
+
+                        addlabel = True
+                        for i in range(len(nulls)-1):
+                            if nulls[i+1]-nulls[i]>1:
+                                fig.plot(alls[nulls[i]+1:nulls[i+1]],allz[nulls[i]+1:nulls[i+1]],
+                                        color=colors[np.mod(k,3)],
+                                        lw=2.0,
+                                        label=curlabel if addlabel else None)
+                                addlabel = False
+
+                    else:
+                        fig.plot(alls,allz,
+                                color=colors[np.mod(k,3)],
+                                lw=2.0,
+                                label=curlabel)
+                k+=1
+
+        fig.cur_ax.set_ylim(zmin,zmax)
+        fig.cur_ax.legend()
+        fig.cur_ax.grid()
+
+        return fig
+
     def plot_mpl(self,show=False,forceaspect=True,fig:Figure=None,ax:Axes=None,labels:dict={}):
         """
         Graphique Matplolib du vecteur
@@ -4814,6 +4892,227 @@ class zone:
         ax.set_yticks(np.arange(zmodmin,zmax,.25))
         fig.canvas.draw()
 
+    def plot_linked_polygons_wx(self, fig:MplFig,
+                             linked_arrays:dict, linked_vec:dict[str,"Zones"]=None,
+                             linestyle:str='-', onlymedian:bool=False,
+                             withtopography:bool = True, ds:float = None):
+        """
+        Création d'un graphique sur base des polygones
+
+        Chaque polygone se positionnera sur base de la valeur Z de ses vertices
+           - façon conventionnelle de définir une longueur
+           - ceci est normalement fait lors de l'appel à 'create_polygon_from_parallel'
+           - si les polygones sont créés manuellement, il faut donc prendre soin de fournir l'information adhoc ou alors utiliser l'rgument 'ds'
+
+        ATTENTION : Les coordonnées Z ne sont sauvegardées sur disque que si le fichier est 3D, autrement dit au format '.vecz'
+
+        :param fig: Figure
+        :param ax: Axes
+        :param linked_arrays: dictionnaire contenant les matrices à lier -- les clés sont les labels
+        :param linked_vec: dictionnaire contenant les instances Zones à lier -- Besoin d'une zone et d'un vecteur 'trace/trace' pour convertir les positions en coordonnées curvilignes
+        :param linestyle: style de ligne
+        :param onlymedian: affiche uniquement la médiane
+        :param withtopography: affiche la topographie
+        :param ds: pas spatial le long de l'axe
+
+        """
+
+        colors=['red','blue','green','darkviolet','fuchsia','lime']
+
+        #Vérifie qu'au moins une matrice liée est fournie, sinon rien à faire
+        exit=True
+        for curlabel, curarray in linked_arrays.items():
+            if curarray.plotted:
+                exit=False
+        if exit:
+            return
+
+        k=0
+
+        zmin=99999.
+        zmax=-99999.
+
+        if ds is None:
+            # Récupération des positions
+            srefs=np.asarray([curpol.myvertices[0].z for curpol in self.myvectors])
+        else:
+            # Création des positions sur base de 'ds'
+            srefs=np.arange(0., float(self.nbvectors) * ds, ds)
+
+        for idx, (curlabel, curarray) in enumerate(linked_arrays.items()):
+            if curarray.plotted:
+
+                logging.info(_('Plotting linked polygons for {}'.format(curlabel)))
+                logging.info(_('Number of polygons : {}'.format(self.nbvectors)))
+                logging.info(_('Extracting values inside polygons...'))
+
+                vals= [curarray.get_values_insidepoly(curpol) for curpol in self.myvectors]
+
+                logging.info(_('Computing stats...'))
+
+                values = np.asarray([cur[0] for cur in vals],dtype=object)
+                valel  = np.asarray([cur[1] for cur in vals],dtype=object)
+
+                zmaxloc=np.asarray([np.max(curval) if len(curval) >0 else -99999. for curval in values])
+                zminloc=np.asarray([np.min(curval) if len(curval) >0 else -99999. for curval in values])
+
+                zmax=max(zmax,np.max(zmaxloc[np.where(zmaxloc>-99999.)]))
+                zmin=min(zmin,np.min(zminloc[np.where(zminloc>-99999.)]))
+
+                if zmax>-99999:
+
+                    zloc = np.asarray([np.median(curpoly) if len(curpoly) >0 else -99999. for curpoly in values])
+
+                    fig.plot(srefs[np.where(zloc!=-99999.)],zloc[np.where(zloc!=-99999.)],
+                            color=colors[np.mod(k,3)],
+                            lw=2.0,
+                            linestyle=linestyle,
+                            label=curlabel+'_median')
+
+                    zloc = np.asarray([np.min(curpoly) if len(curpoly) >0 else -99999. for curpoly in values])
+
+                    if not onlymedian:
+
+                        fig.plot(srefs[np.where(zloc!=-99999.)],zloc[np.where(zloc!=-99999.)],
+                                color=colors[np.mod(k,3)],alpha=.3,
+                                lw=2.0,
+                                linestyle=linestyle,
+                                label=curlabel+'_min')
+
+                        zloc = np.asarray([np.max(curpoly) if len(curpoly) >0 else -99999. for curpoly in values])
+
+                        fig.plot(srefs[np.where(zloc!=-99999.)],zloc[np.where(zloc!=-99999.)],
+                                color=colors[np.mod(k,3)],alpha=.3,
+                                lw=2.0,
+                                linestyle=linestyle,
+                                label=curlabel+'_max')
+
+                if withtopography and idx==0:
+                    if valel[0] is not None:
+                        zmaxloc=np.asarray([np.max(curval) if len(curval) >0 else -99999. for curval in valel])
+                        zminloc=np.asarray([np.min(curval) if len(curval) >0 else -99999. for curval in valel])
+
+                        zmax=max(zmax,np.max(zmaxloc[np.where(zmaxloc>-99999.)]))
+                        zmin=min(zmin,np.min(zminloc[np.where(zminloc>-99999.)]))
+
+                        if zmax>-99999:
+
+                            zloc = np.asarray([np.median(curpoly) if len(curpoly) >0 else -99999. for curpoly in valel])
+
+                            fig.plot(srefs[np.where(zloc!=-99999.)],zloc[np.where(zloc!=-99999.)],
+                                    color='black',
+                                    lw=2.0,
+                                    linestyle=linestyle,
+                                    label=curlabel+'_top_median')
+
+                        # if not onlymedian:
+                            # zloc = np.asarray([np.min(curpoly) for curpoly in valel])
+
+                            # ax.plot(srefs[np.where(zloc!=-99999.)],zloc[np.where(zloc!=-99999.)],
+                            #         color='black',alpha=.3,
+                            #         lw=2.0,
+                            #         linestyle=linestyle,
+                            #         label=curlabel+'_top_min')
+
+                            # zloc = np.asarray([np.max(curpoly) for curpoly in valel])
+
+                            # ax.plot(srefs[np.where(zloc!=-99999.)],zloc[np.where(zloc!=-99999.)],
+                            #         color='black',alpha=.3,
+                            #         lw=2.0,
+                            #         linestyle=linestyle,
+                            #         label=curlabel+'_top_max')
+
+                k+=1
+
+        for curlabel, curzones in linked_vec.items():
+            curzones:Zones
+            names = [curzone.myname for curzone in curzones.myzones]
+            trace = None
+            tracels = None
+
+            logging.info(_('Plotting linked zones for {}'.format(curlabel)))
+
+            curzone: zone
+            if 'trace' in names:
+                curzone = curzones.get_zone('trace')
+                trace = curzone.get_vector('trace')
+
+                if trace is None:
+                    if curzone is not None:
+                        if curzone.nbvectors>0:
+                            trace = curzone.myvectors[0]
+
+                if trace is not None:
+                    tracels = trace.asshapely_ls()
+                else:
+                    logging.warning(_('No trace found in the vectors {}'.format(curlabel)))
+                    break
+
+            if ('marks' in names) or ('repères' in names):
+                if ('marks' in names):
+                    curzone = curzones.myzones[names.index('marks')]
+                else:
+                    curzone = curzones.myzones[names.index('repères')]
+
+                logging.info(_('Plotting marks for {}'.format(curlabel)))
+                logging.info(_('Number of marks : {}'.format(curzone.nbvectors)))
+
+                for curvect in curzone.myvectors:
+                    curls = curvect.asshapely_ls()
+
+                    if curls.intersects(tracels):
+                        inter = curls.intersection(tracels)
+                        curs = float(tracels.project(inter))
+
+                        fig.plot([curs, curs], [zmin, zmax], linestyle='--', label=curvect.myname)
+                        fig.text(curs, zmax, curvect.myname, fontsize=8, ha='center', va='bottom')
+
+            if ('banks' in names) or ('berges' in names):
+
+                if ('banks' in names):
+                    curzone = curzones.myzones[names.index('banks')]
+                else:
+                    curzone = curzones.myzones[names.index('berges')]
+
+                logging.info(_('Plotting banks for {}'.format(curlabel)))
+                logging.info(_('Number of banks : {}'.format(curzone.nbvectors)))
+
+                for curvect in curzone.myvectors:
+                    curvect: vector
+
+                    curproj = curvect.projectontrace(trace)
+                    sz = curproj.asnparray()
+                    fig.plot(sz[:,0], sz[:,1], label=curvect.myname)
+
+            if ('bridges' in names) or ('ponts' in names):
+                if ('bridges' in names):
+                    curzone = curzones.myzones[names.index('bridges')]
+                else:
+                    curzone = curzones.myzones[names.index('ponts')]
+
+                logging.info(_('Plotting bridges for {}'.format(curlabel)))
+
+                for curvect in curzone.myvectors:
+                    curvect: vector
+                    curls = curvect.asshapely_ls()
+
+                    if curls.intersects(tracels):
+
+                        logging.info(_('Bridge {} intersects the trace'.format(curvect.myname)))
+
+                        inter = curls.intersection(tracels)
+                        curs = float(tracels.project(inter))
+                        locz = np.asarray([vert.z for vert in curvect.myvertices])
+                        zmin = np.amin(locz)
+                        zmax = np.amax(locz)
+
+                        fig.plot(curs, zmin, label=curvect.myname + ' min', marker='x')
+                        fig.plot(curs, zmax, label=curvect.myname + ' max', marker='x')
+
+        fig.cur_ax.set_ylim(zmin,zmax)
+        zmodmin= np.floor_divide(zmin*100,25)*25/100
+        fig.cur_ax.set_yticks(np.arange(zmodmin,zmax,.25))
+
     def reset_listogl(self):
         """
         Reset OpenGL lists.

wolfhece/apps/check_install.py

@@ -58,6 +58,45 @@ def main():
         ret += 'Wolfhece not installed properly\n Please install the VC++ redistributable\n from https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads\n\n'
         ret += 'Error : ' + str(e) + '\n\n'
 
+    from pathlib import Path
+    dirlaz = Path(__file__).parent.parent / 'lazviewer'
+    dirs_to_test =  [dirlaz / 'libs', dirlaz / 'libs/qt_plugins', dirlaz / 'libs/qt_plugins/platforms']
+
+    for d in dirs_to_test:
+        if not d.exists() or not d.is_dir():
+            ret += str(d) + ' does not exist\n\n'
+
+    curdir = dirlaz / 'libs/qt_plugins/platforms'
+    files_to_test = [curdir / 'qwindows.dll']
+
+    for f in files_to_test:
+        if not f.exists() or not f.is_file():
+            ret += str(f) + ' does not exist\n\n'
+
+    curdir = dirlaz / 'libs'
+    files_to_test = [curdir / 'icudt53.dll', curdir / 'icuin53.dll', curdir / 'icuuc53.dll',
+                     curdir / 'msvcp120.dll', curdir / 'msvcr120.dll', curdir / 'Qt5Core.dll',
+                     curdir / 'Qt5Gui.dll', curdir / 'Qt5Network.dll', curdir / 'Qt5Widgets.dll',
+                     curdir / 'tbb.dll', curdir / 'tbbmalloc.dll', curdir / 'vcomp120.dll']
+
+    for f in files_to_test:
+        if not f.exists() or not f.is_file():
+            ret += str(f) + ' does not exist\n\n'
+
+    try:
+        from ..lazviewer.viewer import viewer
+        import numpy as np
+
+        pts = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2]])
+        myview = viewer.viewer(pts, debug = True)
+
+        ret += 'LAZ viewer created in debug mode -- check for errors if reported\n\n'
+
+    except ImportError as e:
+        ret += 'Could not import/create LAZ viewer\n\n'
+        ret += 'Wolfhece not installed properly\n Please check if QT \n\n'
+        ret += 'Error : ' + str(e) + '\n\n'
+
     print(ret)
 
 if __name__=='__main__':

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 1
-        self.patch = 119
+        self.patch = 120
 
     def __str__(self):
 

wolfhece/lazviewer/_add_path.py

@@ -1,23 +1,23 @@
-import os
-import os.path
-import sys
-import platform
+# import os
+# import os.path
+# import sys
+# import platform
 
 
-def _add_path():
-    _root_dir = os.path.dirname(os.path.realpath(__file__))
+# def _add_path():
+#     _root_dir = os.path.dirname(os.path.realpath(__file__))
 
-    # manual specify list of dll directories, with paths relative to _root_dir
-    _dll_dirs = ['libs']
+#     # manual specify list of dll directories, with paths relative to _root_dir
+#     _dll_dirs = ['libs']
 
-    if platform.system() == 'Windows':
-        os.environ.setdefault('PATH', '')
-        paths = os.environ['PATH'].split(';')
-        for x in _dll_dirs:
-            x = os.path.join(_root_dir, x)
-            if os.path.isdir(x) and x not in paths:
-                paths = [x] + paths
-        os.environ['PATH'] = ';'.join(paths)
+#     if platform.system() == 'Windows':
+#         os.environ.setdefault('PATH', '')
+#         paths = os.environ['PATH'].split(';')
+#         for x in _dll_dirs:
+#             x = os.path.join(_root_dir, x)
+#             if os.path.isdir(x) and x not in paths:
+#                 paths = [x] + paths
+#         os.environ['PATH'] = ';'.join(paths)
 
 
-_add_path()
+# _add_path()

wolfhece/lazviewer/laz_viewer.py

@@ -23,7 +23,7 @@ from ..PyWMS import getWalonmap
 from ..PyTranslate import _
 from ..color_constants import Colors
 from ..PyParams import Wolf_Param, Type_Param
-from ..matplotlib_fig import Matplotlib_Figure as MplFig
+from ..matplotlib_fig import Matplotlib_Figure as MplFig, PRESET_LAYOUTS
 from ..drawing_obj import Element_To_Draw
 from ..CpGrid import CpGrid
 from ..PyVertexvectors import vector, Zones, zone, wolfvertex
@@ -375,6 +375,35 @@ class xyz_laz_grid():
 
         return retdata
 
+    def find_files_in_bounds(self, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]]):
+        """ Find all files in bounds """
+
+        x1=bounds[0][0]
+        x2=bounds[0][1]
+        y1=bounds[1][0]
+        y2=bounds[1][1]
+
+        file1= self.genfile.split('x1')[0]
+        file2= self.genfile.split('y1')[-1]
+
+        files=[]
+
+        for x in range(int(self.origx), int(self.endx), int(self.dx)):
+            for y in range(int(self.origy), int(self.endy), int(self.dy)):
+
+                locbounds=np.float64(((x,x+self.dx),(y,y+self.dy)))
+
+                test = not(x2 < locbounds[0][0] or x1 > locbounds[0][1] or y2 < locbounds[1][0] or y1 > locbounds[1][1])
+
+                if test:
+                    fxyz = file1+str(int(x))+'_'+str(int(y))+file2
+
+                    fn = join(self.mydir,fxyz)
+                    if exists(fn):
+                        files.append(fn)
+
+        return files
+
     def _split_xyz(self, dirout:str, nbparts:int = 10):
         """ Split XYZ file into 'nb' parts along X and Y """
         for entry in scandir(self.mydir):
@@ -494,7 +523,7 @@ class xyz_laz_grids():
     """ Ensemble de grids """
 
     def __init__(self, dir_grids:str, create:bool=False) -> None:
-        self.grids = []
+        self.grids:list[xyz_laz_grid] = []
         self.colors = Classification_LAZ()
         self.colors.init_2023()
 
@@ -527,6 +556,36 @@ class xyz_laz_grids():
             logging.info(_('Data found -- {} points'.format(ret.shape[0])))
             return ret
 
+    def find_files_in_bounds(self, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]]):
+
+        ret = [(cur.mydir, cur.find_files_in_bounds(bounds)) for cur in self.grids]
+        ret = [cur for cur in ret if len(cur[1])>0]
+
+        if len(ret)==0:
+            logging.info(_('No data found'))
+            return []
+        else:
+            logging.info(_('Data found -- {} files'.format(len(ret))))
+            return ret
+
+    def copy_files_in_bounds(self, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]], dirout:str):
+
+        import shutil
+
+        out = Path(dirout)
+        out.mkdir(exist_ok=True)
+
+        files = self.find_files_in_bounds(bounds)
+
+        for curdir, curfiles in files:
+            locdir = dirout / Path(curdir).parent.name
+            locdir.mkdir(exist_ok=True)
+            for curfile in curfiles:
+                shutil.copy(curfile, locdir / Path(curfile).name)
+
+            # copy gridinfo.txt
+            shutil.copy(join(curdir,'gridinfo.txt'), locdir / 'gridinfo.txt')
+
     def read_dir(self, dir_grids):
         dirs = listdir(dir_grids)
 
@@ -637,14 +696,11 @@ class xyz_laz_grids():
 
         (up_s, up_z, up_color), (down_s, down_z, down_color) = self.scan_around(xy, length_buffer)
 
-        figmpl = MplFig()
-        figmpl.presets()
-        fig = figmpl.fig
-        ax = figmpl.cur_ax
+        figmpl = MplFig(PRESET_LAYOUTS.DEFAULT)
 
         logging.info(_('Plotting'))
-        ax.scatter(up_s,   up_z,  c=up_color  ,marker='.')
-        ax.scatter(down_s, down_z,c=down_color,marker='+')
+        figmpl.plot(up_s,   up_z,  c=up_color  ,marker='.')
+        figmpl.plot(down_s, down_z,c=down_color,marker='+')
 
         if show:
             figmpl.Show()
@@ -883,9 +939,12 @@ class Wolf_LAZ_Data(Element_To_Draw):
 
         nb1 = self.data.shape[0]
         if self.viewer is not None:
-            nb2 = self.viewer.get('num_points')[0]
-            assert nb1 == nb2, _('Incoherent number of points')
-
+            try:
+                nb2 = self.viewer.get('num_points')[0]
+                assert nb1 == nb2, _('Incoherent number of points')
+            except:
+                # viewer is not initialized or Destroyed
+                self.viewer = None
         return nb1
 
     @property
@@ -1138,7 +1197,7 @@ class Wolf_LAZ_Data(Element_To_Draw):
     def bounds(self, value):
         self._bounds = value
 
-    def from_grid(self, grid:xyz_laz_grid, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]]):
+    def from_grid(self, grid:xyz_laz_grids, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]]):
         """ Create data from grid LAZ """
         self.bounds = bounds
         self.data = grid.scan(bounds)
@@ -1482,7 +1541,7 @@ class Wolf_LAZ_Data(Element_To_Draw):
         props = self._myprops
 
         self.lookat = (props[('Look at', 'X')], props[('Look at', 'Y')], props[('Look at', 'Z')])
-        self.eye = (props[('Camera', 'X')], props[('Camera', 'Y')], props[('Camera', 'Z')])
+        # self.eye = (props[('Camera', 'X')], props[('Camera', 'Y')], props[('Camera', 'Z')])
 
         color = np.asarray(props[('Background', 'Color')])
         self.bg_color(color / 255.)

wolfhece/lazviewer/viewer/qt.conf

@@ -0,0 +1,2 @@
+[Paths]
+Plugins=../libs/qt_plugins

wolfhece/lazviewer/viewer/viewer.py

@@ -12,8 +12,12 @@ _viewer_dir = os.path.dirname(inspect.getfile(inspect.currentframe()))
 if not os.path.isabs(_viewer_dir):
     _viewer_dir = os.path.abspath(_viewer_dir)
 
-__all__ = ['viewer']
+_viewer_libs_dir = os.path.join(_viewer_dir, '../libs')
+
+if not os.path.isabs(_viewer_libs_dir):
+    _viewer_libs_dir = os.path.abspath(_viewer_libs_dir)
 
+__all__ = ['viewer']
 
 class viewer:
     def __init__(self, *args, **kwargs):
@@ -22,7 +26,7 @@ class viewer:
         Examples:
             Create 100 random points
 
-            >>> xyz = pptk.rand(100, 3)
+            >>> xyz = pptk.rand(100, 3)python
 
             Visualize the points
 
@@ -49,10 +53,16 @@ class viewer:
         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         s.bind(('localhost', 0))
         s.listen(0)
-        self._process = subprocess.Popen(
-            [os.path.join(_viewer_dir, 'viewer'), str(s.getsockname()[1])],
-            stdout=subprocess.PIPE,
-            stderr=(None if debug else subprocess.PIPE))
+
+        env = os.environ.copy()
+        env["PATH"] = _viewer_dir + os.pathsep + _viewer_libs_dir + os.pathsep + env["PATH"]
+        # print(env["PATH"])
+
+        self._process = subprocess.Popen([os.path.join(_viewer_dir, 'viewer'),
+                                          str(s.getsockname()[1])],
+                                          stdout=subprocess.PIPE,
+                                          stderr=(None if debug else subprocess.PIPE),
+                                          env = env)
         if debug:
             print ('Started viewer process: %s' \
                 % os.path.join(_viewer_dir, 'viewer'))