Beispiel #1
0
class EpochList(object):
    """
    list of Epoch instances
    like project
    """

    def __init__(self, 
                 stdevUseApriori=True,
                 confProb=0.95,
                 reliabProb=0.95,
                 #config=None,
                 duplicateFixId=DUPLICATE_ID.compare,
                 textTable=None):
        """
        stdevUseApriori: use apriori/aposteriori standard deviation
        confProb: confidence probability
        reliabProb: reliability probability
        config: project configuration file
        duplicateFixId: what to do with duplicate fixed points in epoch
        textTable: text table instance for epochPointList
        """

        self.numEpoch = 0 # the number of epoch added
        #self.epochList = []

        self.dateTimeList = [] # list of dates of epochs, datetime instances
        self.epochPointList = EpochPointList()
            # list of coordinates, displacements and test results
            # PointLocalGamaDisplTest instances
        
        self.pointListFix = PointList(textTable=gama_coor_table(), 
                                      duplicateId=duplicateFixId)
            # list of fixed points for all epochs

        self.coordSystemLocal = CoordSystemLocal2D()
            # definition of local geodetic system
        
        self.stdevList = []
            # list of StandardDeviation instances
            # handles degrees of freedom from GamaLocalData instance

        self._stdevUseApriori = stdevUseApriori

        self._confProb = confProb

        self.reliabProb = reliabProb

        self.testType = None

        if textTable is None:
            from gizela.stat.displ_test_text_table import displ_test_text_table
            self.textTable = displ_test_text_table()
        else:
            self.textTable = textTable

        #print self.textTable

        #self.id = self.epochPointList.index # just shorter name
        #self.axesOri = None # orientation of axes
        #self.coordSystem = None # system of coordinates
        #self.ellipsoid = None # ellipsoid instance

        #self.numPoint = 0 # the number of points in x, y and z lists
        #self.id = {} # dictionary of point ids and indexes in x, y, z lists
        #self.x = [] # list of lists of x coordinates
        #self.y = [] # list of lists of y coordinates
        #self.z = [] # list of lists of z coordinates
        #self.covmat = [] # list of covariance matrices of points

        # plots
        #self.displacementScale = 10.0 # scale factor for displacements
        #self.confScale1d = 1.0 # scale factor for confidence interval 
        #self.confScale2d = 1.0 # scale factor for confidence ellipse 
        #self.cmap = 'hsv'
        #self.pointStyleList = [] # properties for points in each epoch
                                 # PointStyleGama instances
        #self.errEllStyle = ErrEllStyle # properties for error ellipses
        #self.vecStyle = VecStyle # properties for vectors of displacements
        #self.dateStyle = DateStyle # properties for date plots
        #self.stdevStyle = StdevStyle # properties for standard deviation interval
        #if config is not None:
            # parsing configuration file
            #self.parse_config_file(config)

    
    def add_epoch(self, epoch, addCoordSystem=True):
        """adds GamaLocalData instance to list of epochs"""

        if not isinstance(epoch, Epoch):
            raise EpochListError, "Epoch instance expected"
        
        # add epoch
        self.numEpoch += 1
        #self.epochList.append(epoch)

        # stdev
        epoch.pointListAdj.covmat.useApriori = self._stdevUseApriori
        epoch.stdev.set_conf_prob(self._confProb)
        epoch.stdev.set_use(self._stdevUseApriori and "apriori" or
                                  "aposteriori")
        self.stdevList.append(epoch.stdev)


        # add epoch time and date
        self.dateTimeList.append(datetime.datetime(epoch.date.year,
                                                   epoch.date.month,
                                                   epoch.date.day,
                                                   epoch.time.hour,
                                                   epoch.time.minute,
                                                   epoch.time.second,
                                                   epoch.time.microsecond,
                                                   epoch.time.tzinfo))

        # change type of point
        pl = PointListCovMat(covmat=epoch.pointListAdj.covmat,
                             textTable=self.textTable)
        for p in epoch.pointListAdj:
            pp = PointLocalGamaDisplTest(p)
            pp.epochIndex = self.numEpoch - 1
            pl.add_point(pp)

        # compute differences - previous epoch
        #if self.numEpoch > 1:
        #    lastEpoch = self.epochPointList.get_epoch(-1)
        #    for p in pl:
        #        if p.id in lastEpoch:
        #            # compute displacement
        #            pd = p - lastEpoch.get_point(p.id)
        #            #print pd.id, pd.covmat.data
        #            # add displacement 
        #            p.set_displacement(pd)
        #from gizela.stat.displ_test_text_table import point_displ_text_table
        #pl.textTable = point_displ_text_table()
        #print pl

        for p in pl:
            # find point in "zero" epoch
            p0 = None
            if p.id in self.epochPointList.iter_id():
                for pp in self.epochPointList.iter_point(p.id):
                    if p.is_set_xyz() and pp.is_set_xyz():
                        p0 = pp
                        break
                    elif p.is_set_xy() and pp.is_set_xy():
                        p0 = pp
                        break
                    elif p.is_set_z() and pp.is_set_z():
                        p0 = pp
                        break
                if p0 is None:
                    # no point found
                    continue

                #print "type p", type(p)
                #print "minus", type((p - p0).covmat)
                #from gizela.data.point_text_table import gama_coor_var_table
                #print (p-p0).with_text_table(gama_coor_var_table())
                p.set_displacement(p - p0)

        # add adjusted points
        self.epochPointList.add_epoch(pl)
        #for p in self.epochPointList.get_epoch(-1):
        #    print p.id,"covmat", p.covmat.make_gama_xml()
        #    print p.id,"var", p.var

        # add fixed points
        self.pointListFix.extend(epoch.pointListFix)
        

    def get_epoch_point_list(self, index):
        return self.epochPointList.get_epoch(index)

    
    def plot_xy(self, figure, idAdj=None, idFix=None, plotTest=False):
        """
        plots figure with points and error ellipses and displacements

        figure: FigureLayoutBase instance or descendant
        idAdj: list of ids of adjusted points to be drawn
               for no adjusted points set idAdj = []
        idFix: plot fixed points
               for no fixed points set idFix = []

        """

        # id of points
        if idAdj is None:
            idAdj = [id for id in self.epochPointList.iter_id()]
        
        if idFix is None:
            idFix = [id for id in self.pointListFix.iter_id()]

        # plot adjusted
        if len(idAdj) > 0:
           self.plot_adj(figure, idAdj, plotErrorZ=False, plotTest=plotTest)
        
        # plot fixed
        if len(idFix) > 0:
            self.plot_fix(figure, idFix)

    def plot_xyz(self, figure, idAdj=None, idFix=None, plotTest=False):
        """
        plots figure with points, error ellipses, displacements
        and confidence interval of z along y axis

        figure: FigureLayoutBase instance or descendant
        idAdj: list of ids of adjusted points to be drawn
               for no adjusted points set idAdj = []
        idFix: plot fixed points
               for no fixed points set idFix = []

        """

        # id of points
        if idAdj is None:
            idAdj = [id for id in self.epochPointList.iter_id()]
        
        if idFix is None:
            idFix = [id for id in self.pointListFix.iter_id()]

        # plot adjusted
        if len(idAdj) > 0:
           self.plot_adj(figure, idAdj, plotErrorZ=True, plotTest=plotTest)
        
        # plot fixed
        if len(idFix) > 0:
            self.plot_fix(figure, idFix)

    
    def plot_z(self, figure, id, plotTest=False):
        """plot x coordinates of point id for all epochs with stdev

        self: EpochList isntance
        id: id or ids of point
        """

        if type(id) is not tuple and type(id) is not list:
            id = (id,)

        # set figure
        figure.set_color_style(self)
        figure.gca().xaxis_date()


        # plot points
        for idi in id:
            self._plot_epoch_list_displacement_z(figure, idi, plotTest)
            figure.reset_epoch_counter()
        
        # set free space around draw
        figure.set_free_space()

        #update
        figure.update_(self)
        

    def _plot_epoch_list_displacement_z(self, figure, id, plotTest): 
        """
        plot 2D graph of point z coordinates,
        confidence intervals of z coordinates and displacements for all epochs

        id: point id
        plotTest: plot results of test?
        """

        # point iterator
        pointIter = self.epochPointList.iter_point(id)
        # plot points and stdev
        z = [] # z coordinates of points
        for point, date in zip(pointIter, self.dateTimeList):
            point.plot_z(figure, date)
            if plotTest:
                if point.testPassed is not None: # point is tested
                    point.plot_z_stdev(figure, date)
            else:
                point.plot_z_stdev(figure, date)
                
            figure.next_point_dot_style()
            z.append(point.z)

        point0 = None
        for p, i in zip(self.epochPointList.iter_point(id), 
                        xrange(self.numEpoch)):
            if p.is_set_z():
                point0 = p
                i_epoch = i
                break

        # label point0
        if point0 is not None:
            point0.x = self.dateTimeList[i_epoch]
            point0.y = point.z
            point0.plot_label(figure)

        # plot vector
        figure.plot_vector_z(self.dateTimeList, z)

        # plot zero line
        if point0 is not None:
            z0 = [point0.z for t in self.dateTimeList]
            figure.plot_vector_z0(self.dateTimeList, z0)

    
    def plot_fix(self, figure, id):
        """
        plots 2D graph of fixed points
        """

        figure.set_aspect_equal()
        figure.update_(self) 

        for idi in id:
            self.pointListFix.plot_(figure)

        # set free space around draw
        figure.set_free_space()
        

    def plot_adj(self, figure, id, plotErrorZ, plotTest):
        """
        plots 2D graph of adjusted points, displacements and error ellipses

        figure: FigureLayoutBase instance
        id: id or ids of point
        plotErrorZ: plot confidence interval of z coordinate?
        plotTest: plot results of test?
        """

        if type(id) is not tuple and type(id) is not list:
            id = [id]

        # update figure 
        figure.set_aspect_equal()
        figure.update_(self)

        # plot points
        for idi in id:
            self._plot_epoch_list_displacement_xy(figure, idi, plotErrorZ,
                                                plotTest)
            figure.reset_epoch_counter()
        
        # set free space around draw
        figure.set_free_space()

    def _plot_epoch_list_displacement_xy(self, figure, id, 
                                          plotErrorZ, plotTest): 
        """
        plot 2D graph of point ,
        error ellipses and displacements for all epochs
        and optionally confidence interval of z coordinate along y axis

        id: point id
        plotErrorZ: plot confidence interval of z coordinate?
        plotTest: plot results of test?
        """
        
        # point iterator
        pointIter = self.epochPointList.iter_point(id)
        
        # find zero epoch for point
        # the first point with x!=None and y!=None
        point0 = None
        for p in pointIter:
            if p.x != None and p.y != None:
                point0 = p
                #x0, y0 = point0.x, point0.y
                break
        if point0 == None:
            return # no xy point available

        # point iterator
        pointIter = self.epochPointList.iter_point(id)
        
        # save coordinates of vector with scale
        pointScaled = [] # point list as normal list
        for p in pointIter:
            if plotTest:
                covmat = p.displ.get_point_cov_mat()
            else:
                covmat = p.get_point_cov_mat()
            ps = (p - point0)*figure.errScale + point0
            ps.covmat = covmat
            #print "epl:", type(ps)
            pointScaled.append(ps)

        # plot points and error ellipses
        for p in pointScaled:
            p.plot_(figure, plotLabel=False)
            figure.set_stdev(self) # sets StandardDeviation instance for epoch
            if plotTest:
                if p.testPassed is not None: # point is tested
                    p.plot_error_ellipse(figure)
            else:
                p.plot_error_ellipse(figure)
                
            figure.next_point_dot_style()

        # label point0
        point0.plot_label(figure)
        
        # plot vector
        figure.plot_vector_xy(pointScaled)

    def __str__(self):
        tt = TextTable([("epoch", "%5i"), ("date","%10s"), ("time","%8s")])
        str = [tt.make_table_head()]
        str.extend([tt.make_table_row(i, dt.date(), dt.time())\
                    for dt,i in zip(self.dateTimeList,
                                    xrange(len(self.dateTimeList)))])
        str.append(tt.make_table_foot())
        str.append("\n")
        str.append(self.epochPointList.__str__())

        return "".join(str)

    def get_epoch_table(self, index=None):
        "returns text table of displacements"
        str = []
        if index is None:
            for i, e in zip(xrange(self.epochPointList.get_num_epoch()),
                            self.epochPointList.iter_epoch()):
                str.append("Epoch %i:" % i)
                str.append(e.__str__())
        else:
                str.append("Epoch %i:" % index)
                str.append(self.epochPointList.get_epoch(index).__str__())

        return "\n".join(str)

    def set_stdev_use(self, use):
        """
        set which standart deviation to use
        """

        if use is "apriori":
            self._stdevUseApriori = True
            for pl in self.pointListAdj.iter_epoch():
                pl.covmat.useApriori = True
            for s in self.stdevList:
                s.set_stdev_use_apriori()
        elif use is "aposteriori":
            self._stdevUseApriori = False
            for pl in self.pointListAdj.iter_epoch():
                pl.covmat.useApriori = False
            for s in self.stdevList:
                s.set_stdev_use_aposteriori()
        else:
            raise EpochListError, "Unknown value of parameter use: %s" % use

    def set_stdev_use_apriori(self):
        self.set_stdev_use("apriori")
    
    def set_stdev_use_aposteriori(self):
        self.set_stdev_use("aposteriori")

    def get_stdev_use(self): 
        return self._stdevUseApriori and "apriori" or "aposteriori"


    #def parse_config_file(self, fileName):

    #    import ConfigParser
    #    configParser = ConfigParser.SafeConfigParser()
    #    configParser.optionxform = str # to make options case sensitive
 
    #    readed = configParser.read(fileName)
    #    
    #    print "Fonfiguration file(s) readed: %s" % ", ".join(readed)
    #    
    #    self.config = {}

    #    for sec in configParser.sections():
    #        self.config[sec] = {}
    #        for p,v in configParser.items(sec):
    #            print p, v
    #            try:
    #                v=float(v)
    #            except:
    #                pass
    #            self.config[sec][p]=v

    #    #print self.config
    #    
    #    from gizela.util.Converter import Converter as con

    #    # local system
    #    try:
    #        self.coordSystemLocal = CoordSystemLocal(\
    #           ellipsoidCode = self.config["localSystem"]["ellipsoid"],
    #           lat = con.deg2rad_(self.config["localSystem"]["latitude"]),
    #           lon = con.deg2rad_(self.config["localSystem"]["longitude"]),
    #                  height = self.config["localSystem"]["height"],
    #                       x = self.config["localSystem"]["x"],
    #                       y = self.config["localSystem"]["y"],
    #                       z = self.config["localSystem"]["z"],
    #                 axesOri = self.config["localSystem"]["axesOri"],
    #              bearingOri = self.config["localSystem"]["bearingOri"],
    #                    name = self.config["localSystem"]["name"],
    #             description = self.config["localSystem"]["description"]
    #        )
    #    except:
    #        import sys
    #        print >>sys.stderr, "Warning: Local system not set."

    #    # standard deviation
    #    try:
    #        if self.config["stdev"]["use"] is "apriori":
    #            self.set_stdev_use("apriori")
    #        elif self.config["stdev"]["use"] is "aposteriori":
    #            self.set_stdev_use("aposteriori")
    #    except:
    #        import sys
    #        print >>sys.stderr, "Warning: Use of standard deviation not set"


    def compute_displacement_test(self, pointId=None, testType=None):
        """
        computes test statistic for displacements of points
        pointId: ids of point to be tested
        testType: type of test see DisplacementTestType class
                  or None for testing according to point dimension
        """

        self.testType = testType
        from gizela.stat.DisplacementTest import DisplacementTest
        dtest = DisplacementTest(apriori=self._stdevUseApriori,
                                 confProb=self._confProb,
                                 reliabProb=self.reliabProb)
        dtest.compute_test(self.epochPointList, pointId, testType)

    def get_conf_prob(self):
        return self._confProb

    def set_conf_prob(sefl, confProb):
        self._confProb = confProb
        for s in self.stdevList:
            s.set_conf_prob(confProb)
Beispiel #2
0
class NetworkAdjList(NetworkList):
    """
    list of Epoch instances
    like project
    """

    def __init__(self, 
                 coordSystemLocal,
                 stdevUseApriori=True,
                 confProb=0.95,
                 reliabProb=0.95,
                 testId=None,
                 duplicateIdFix=DUPLICATE_ID.compare,
                 duplicateIdAdj=DUPLICATE_ID.compare,
                 textTable=None):
        """
        stdevUseApriori: use apriori/aposteriori standard deviation
        confProb: confidence probability
        reliabProb: reliability probability
        testId: Ids of point for testing (currently only for output)
        duplicateFixId: what to do with duplicate fixed points in epoch
        textTable: text table instance for epochPointList
        """

        NetworkList.__init__(self, 
                             coordSystemLocal,
                             stdevUseApriori=stdevUseApriori,
                             confProb=confProb,
                             #reliabProb=reliabProb,
                             #duplicateIdFix=duplicateIdFix,
                             duplicateIdAdj=duplicateIdAdj)
        
        self.pointListAdj = PointList(textTable=gama_coor_table(), 
                                      duplicateId=duplicateIdFix)
            # list of fixed points for all epochs

        self.epochPointList = EpochPointList(idList=testId)
            # list of coordinates, displacements and test results
            # PointLocalGamaDisplTest instances

        self.stdevList = []
            # list of StandardDeviation instances
            # handles degrees of freedom from GamaLocalData instance

        ##self.testType = None

        if textTable is None:
            from gizela.stat.displ_test_text_table import displ_test_text_table
            self._textTable = displ_test_text_table()
        else:
            self._textTable = textTable

        self._reliabProb = reliabProb

    def _get_textTable(self):
        return self._textTable

    def _set_textTable(self, textTable):
        self._textTable = textTable
        for epoch in self.list:
            epoch.pointListAdjCovMat.textTable = textTable

    textTable = property(_get_textTable, _set_textTable)

    
    def append(self, net):
        """
        adds GamaLocalData instance to list of nets
        """

        if not isinstance(net, Network):
            raise NetworkAdjListError, "Network instance expected"

        NetworkList.append(self, net)

        # standard deviation
        net.stdev.set_use_apriori(self._stdevUseApriori)
        net.stdev.set_conf_prob(self._confProb)
        net.pointListAdjCovMat.covmat.useApriori = self._stdevUseApriori
        self.stdevList.append(net.stdev)

        # change textTable of pointList
        net.pointListAdjCovMat.textTable = self._textTable

        # compute displacements of net added
        #
        # compute differences from "zero" epoch
        for pp in net.pointListAdjCovMat:
            # change type of point
            p = PointLocalGamaDisplTest(pp)
            #p.epochIndex = len(self)# - 1
            p.epochIndex = len(self) - 1

            #import sys
            #from gizela.data.point_text_table import gama_coor_stdev_table
            #print >>sys.stderr, pp.with_text_table(gama_coor_stdev_table())
            #print >>sys.stderr, p.with_text_table(gama_coor_stdev_table())
            
            # find point in "zero" epoch
            
            p0 = None
            if p.id in self.epochPointList.iter_id():
                for pp in self.epochPointList.iter_point(p.id):
                    if p.is_set_xyz() and pp.is_set_xyz():
                        p0 = pp
                        break
                    elif p.is_set_xy() and pp.is_set_xy():
                        p0 = pp
                        break
                    elif p.is_set_z() and pp.is_set_z():
                        p0 = pp
                        break
                if p0 is not None:
                    #print "type p", type(p)
                    #print "minus", type((p - p0).covmat)
                    #from gizela.data.point_text_table import gama_coor_stdev_table
                    #print (p-p0).with_text_table(gama_coor_stdev_table())
                    p.set_displacement(p - p0)

            net.pointListAdjCovMat.replace_point(p)

        # compute differences - previous epoch
        #if self.numEpoch > 1:
        #    lastEpoch = self.epochPointList.get_epoch(-1)
        #    for p in pl:
        #        if p.id in lastEpoch:
        #            # compute displacement
        #            pd = p - lastEpoch.get_point(p.id)
        #            #print pd.id, pd.covmat.data
        #            # add displacement 
        #            p.set_displacement(pd)
        #from gizela.stat.displ_test_text_table import point_displ_text_table
        #pl.textTable = point_displ_text_table()
        #print pl


        # add adjusted points with displacements
        self.epochPointList.add_(net.pointListAdjCovMat)
        #for p in self.epochPointList.get_epoch(-1):
        #    print p.id,"covmat", p.covmat.make_gama_xml()
        #    print p.id,"var", p.var

        # add fixed points
        self.pointListAdj.extend(net.pointListAdj)


    def append_joined(self, data, reString, epochIndex, pointIndex):
        """
        separate data with joined epochs and add them

        data: Network instance with adjustment
        reString: regular expression with two groups - point id, 
                                                     - epoch index from 0
        epochIndex: index of epoch number (0 or 1) in regular expression groups
        pointIndex: index of point id (0 or 1) in regular expression groups
        """

        if not isinstance(data, Network):
            raise NetworkAdjList, "Network instance expected"

        # set text table
        data.pointListAdjCovMat.textTable = self._textTable

        # separate epochs
        self.epochPointList.add_joined(data.pointListAdjCovMat,
                                       reString, 
                                       epochIndex, pointIndex)

        # add epochs
        for i in xrange(self.epochPointList.get_num_epoch()):
            self.list.append(data)
        self.dateTimeList.extend(data.dateTimeList)

        # standard deviation
        data.stdev.set_use_apriori(self._stdevUseApriori)
        data.stdev.set_conf_prob(self._confProb)
        data.pointListAdjCovMat.covmat.useApriori = self._stdevUseApriori
        for i in xrange(self.epochPointList.get_num_epoch()):
            self.stdevList.append(data.stdev)
        
        # compute displacements
        #
        # change type of points
        for id, ind in self.epochPointList.index.items():
            #print id, ind
            for i, ii in enumerate(ind):
                if ii is not None:
                    pp = PointLocalGamaDisplTest(\
                                     self.epochPointList.list[i].list[ii])
                    pp.epochIndex = i
                    self.epochPointList.list[i].list[ii] = pp
                    #print self.epochPointList.list[i].list[ii]

        # add fixed points
        self.pointListAdj.extend(data.pointListAdj)

        # compute differences from "zero" epoch
        for id, ind in self.epochPointList.index.items():
            for i, ii in enumerate(ind):
                if ii is None:
                    continue
                p = self.epochPointList.list[i].list[ii]
                p0 = None
                for j, jj in enumerate(ind[:i]):
                    if jj is None:
                        continue
                    pp = self.epochPointList.list[j].list[jj]
                    if p.is_set_xyz() and pp.is_set_xyz():
                        p0 = pp
                        break
                    elif p.is_set_xy() and pp.is_set_xy():
                        p0 = pp
                        break
                    elif p.is_set_z() and pp.is_set_z():
                        p0 = pp
                        break
                if p0 is None:
                    # point in "zero" epoch not found
                    continue

                p.set_displacement(p - p0)
           

    def get_epoch_point_list(self, index):
        return self.epochPointList.get_epoch(index)


    def __str__(self):
        tt = TextTable([("epoch", "%5i"), ("date","%10s"), ("time","%8s")])
        str = [tt.make_table_head()]
        str.extend([tt.make_table_row(i, dt.date(), dt.time())\
                    for dt,i in zip(self.dateTimeList,
                                    xrange(len(self.dateTimeList)))])
        str.append(tt.make_table_foot())
        str.append("\n")
        str.append(self.epochPointList.__str__())

        return "".join(str)


    def get_epoch_table(self, index=None):
        """
        returns text table of displacements

        index: integer: index of epoch, None = all epoch
        """
        str = []
        if index is None:
            for i, e in enumerate(self.epochPointList.iter_epoch()):
                str.append("Epoch %i:" % i)
                str.append(e.__str__())
        else:
                str.append("Epoch %i:" % index)
                str.append(self.epochPointList.get_epoch(index).__str__())

        return "\n".join(str)

    def set_stdev_use(self, use):
        """
        set which standart deviation to use
        """

        if use is "apriori":
            self._stdevUseApriori = True
            for pl in self.epochPointList.iter_epoch():
                pl.covmat.useApriori = True
            for s in self.stdevList:
                s.set_stdev_use_apriori()
        elif use is "aposteriori":
            self._stdevUseApriori = False
            for pl in self.epochPointList.iter_epoch():
                pl.covmat.useApriori = False
            for s in self.stdevList:
                s.set_stdev_use_aposteriori()
        else:
            raise EpochListError, "Unknown value of parameter use: %s" % use

    def set_stdev_use_apriori(self):
        self.set_stdev_use("apriori")
    
    def set_stdev_use_aposteriori(self):
        self.set_stdev_use("aposteriori")

    def get_stdev_use(self): 
        return self._stdevUseApriori and "apriori" or "aposteriori"

    
    def plot_xy(self, figure, idAdj=None, idFix=None, plotTest=False):
        """
        plots figure with points and error ellipses and displacements

        figure: FigureLayoutBase instance or descendant
        idAdj: list of ids of adjusted points to be drawn
               for no adjusted points set idAdj = []
        idFix: plot fixed points
               for no fixed points set idFix = []
        """

        # id of points
        if idAdj is None:
            idAdj = [id for id in self.epochPointList.iter_id()]
        
        if idFix is None:
            idFix = [id for id in self.pointListAdj.iter_id()]

        # plot adjusted
        if len(idAdj) > 0:
           self.plot_adj(figure, idAdj, plotErrorZ=False, plotTest=plotTest)
        
        # plot fixed
        if len(idFix) > 0:
            self.plot_fix(figure, idFix)

    def plot_xyz(self, figure, idAdj=None, plotTest=False):
        """
        plots figure with points, error ellipses, displacements
        and confidence interval of z along y axis

        figure: FigureLayoutBase instance or descendant
        idAdj: list of ids of adjusted points to be drawn
               for no adjusted points set idAdj = []
        #idFix: plot fixed points
        #       for no fixed points set idFix = []

        """

        # id of points
        if idAdj is None:
            idAdj = [id for id in self.epochPointList.iter_id()]
        
        #if idFix is None:
        #    idFix = [id for id in self.pointListFix.iter_id()]

        # plot adjusted
        if len(idAdj) > 0:
           self.plot_adj(figure, idAdj, plotErrorZ=True, plotTest=plotTest)
        
        # plot fixed
        #if len(idFix) > 0:
        #    self.plot_fix(figure, idFix)

    
    def plot_z(self, figure, id, plotTest=False):
        """plot x coordinates of point id for all epochs with stdev

        self: EpochList isntance
        id: id or ids of point
        """

        if type(id) is not tuple and type(id) is not list:
            id = (id,)

        # set figure
        figure.set_color_style(self)
        figure.gca().xaxis_date()


        # plot points
        for idi in id:
            self._plot_epoch_list_displacement_z(figure, idi, plotTest)
            figure.reset_epoch_counter()
        
        # set free space around draw
        figure.set_free_space()

        #update
        figure.update_(self)
        

    def _plot_epoch_list_displacement_z(self, figure, id, plotTest): 
        """
        plot 2D graph of point z coordinates,
        confidence intervals of z coordinates and displacements for all epochs

        id: point id
        plotTest: plot results of test?
        """

        # point iterator
        pointIter = self.epochPointList.iter_point(id)
        # plot points and stdev
        z = [] # z coordinates of points
        for point, date in zip(pointIter, self.dateTimeList):
            point.plot_z(figure, date)
            if plotTest:
                if point.testPassed is not None: # point is tested
                    point.plot_z_stdev(figure, date)
            else:
                point.plot_z_stdev(figure, date)
                
            figure.next_point_dot_style()
            z.append(point.z)

        point0 = None
        for i, p in enumerate(self.epochPointList.iter_point(id)): 
            if p.is_set_z():
                point0 = p
                i_epoch = i
                break

        # label point0
        if point0 is not None:
            point0.x = self.dateTimeList[i_epoch]
            point0.y = point.z
            point0.plot_label(figure)

        # plot vector
        figure.plot_vector_z(self.dateTimeList, z)

        # plot zero line
        if point0 is not None:
            z0 = [point0.z for t in self.dateTimeList]
            figure.plot_vector_z0(self.dateTimeList, z0)

    
    def plot_fix(self, figure, id):
        """
        plots 2D graph of fixed points
        """

        figure.set_aspect_equal()
        figure.update_(self) 

        for idi in id:
            self.pointListAdj.plot_(figure)

        # set free space around draw
        figure.set_free_space()
        

    def plot_adj(self, figure, id, plotErrorZ, plotTest):
        """
        plots 2D graph of adjusted points, displacements and error ellipses

        figure: FigureLayoutBase instance
        id: id or ids of point
        plotErrorZ: plot confidence interval of z coordinate?
        plotTest: plot results of test?
        """

        if type(id) is not tuple and type(id) is not list:
            id = [id]

        # update figure 
        figure.set_aspect_equal()
        figure.update_(self)

        # plot points
        for idi in id:
            self._plot_epoch_list_displacement_xy(figure, idi, plotErrorZ,
                                                plotTest)
            figure.reset_epoch_counter()
        
        # set free space around draw
        figure.set_free_space()

    def _plot_epoch_list_displacement_xy(self, figure, id, 
                                          plotErrorZ, plotTest): 
        """
        plot 2D graph of point ,
        error ellipses and displacements for all epochs
        and optionally confidence interval of z coordinate along y axis

        id: point id
        plotErrorZ: plot confidence interval of z coordinate?
        plotTest: plot results of test?
        """
        
        # find zero epoch for point
        # the first point with x!=None and y!=None
        point0 = None
        for p in self.epochPointList.iter_point(id, withNone=False):
            if p.x != None and p.y != None:
                point0 = p
                #x0, y0 = point0.x, point0.y
                break
        if point0 == None:
            return # no xy point available

        # save coordinates of vector with scale
        pointScaled = [] # point list as normal list
        for p in self.epochPointList.iter_point(id, withNone=True):
            if plotTest and isinstance(p, PointLocalGamaDisplTest): 
                    covmat = p.displ.get_point_cov_mat()
            else:
                covmat = p.get_point_cov_mat()
            ps = (p - point0)*figure.errScale + point0
            ps.covmat = covmat
            #import sys
            #print >>sys.stderr, "Point: %s" % ps.id
            #print >>sys.stderr, "epl: %s" % type(ps)
            pointScaled.append(ps)

        # plot points and error ellipses
        for p in pointScaled:
            p.plot_(figure, plotLabel=False)
            figure.set_stdev(self) # sets StandardDeviation instance for epoch
            if plotTest and isinstance(p, PointLocalGamaDisplTest): 
                if p.testPassed is not None: # point is tested
                    p.plot_error_ellipse(figure)
            else:
                p.plot_error_ellipse(figure)
                
            figure.next_point_dot_style()

        # label point0
        point0_label = copy.deepcopy(point0)
        point0_label.id = id
        point0_label.plot_label(figure)
        
        # plot vector
        figure.plot_vector_xy(pointScaled)


    def compute_displacement_test(self, pointId=None, testType=None):
        """
        computes test statistic for displacements of points
        pointId: ids of point to be tested
        testType: type of test see DisplacementTestType class
                  or None for testing according to point dimension
        """

        #self.testType = testType
        from gizela.stat.DisplacementTest import DisplacementTest
        dtest = DisplacementTest(apriori=self._stdevUseApriori,
                                 confProb=self._confProb,
                                 reliabProb=self._reliabProb)
        dtest.compute_test(self.epochPointList, pointId, testType)

    def get_conf_prob(self):
        return self._confProb

    def set_conf_prob(sefl, confProb):
        self._confProb = confProb
        for s in self.stdevList:
            s.set_conf_prob(confProb)

    def _num_epoch(self): return len(self)

    numEpoch = property(_num_epoch)