Esempio n. 1
0
    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)
Esempio n. 2
0
    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)
Esempio n. 3
0
    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)