Changeset 1034


Ignore:
Timestamp:
08/29/12 17:05:06 (5 years ago)
Author:
jjr8
Message:

Working on enhancements to the CreatePointsAlongLines? tool for bbest.

Location:
MGET/Branches/Jason/PythonPackage/src/GeoEco
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • MGET/Branches/Jason/PythonPackage/src/GeoEco/Dependencies.py

    r986 r1034  
    600600    # 
    601601    # For this to succeed, the module has to be able to load the GDAL 
    602     # library (e.g. gdal18.dll on Windows). This usual technique for 
     602    # library (e.g. gdal19.dll on Windows). This usual technique for 
    603603    # this involves adding the GDAL bin directory to the PATH 
    604604    # environment variable prior to importing the module. But this 
     
    643643 
    644644                try: 
    645                     gdalDLLPath = os.path.join(gdalBinDir, 'gdal18.dll') 
     645                    gdalDLLPath = os.path.join(gdalBinDir, 'gdal19.dll') 
    646646                    try: 
    647647                        globals()['_GDALModuleHandle'] = win32api.LoadLibrary(gdalDLLPath) 
  • MGET/Branches/Jason/PythonPackage/src/GeoEco/SpatialAnalysis/Points.py

    r1033 r1034  
    401401                else: 
    402402                    interval = datetime.timedelta(seconds=interval) 
     403                DistanceFromMeters = lambda(d): d 
    403404 
    404405            # Otherwise, if it is linear, convert it to meters. 
     
    407408                if unit == u'feet': 
    408409                    interval *= 0.3048 
     410                    DistanceFromMeters = lambda(d): d / 0.3048 
    409411                elif unit == u'kilometers': 
    410412                    interval *= 1000 
     413                    DistanceFromMeters = lambda(d): d / 1000. 
    411414                elif unit == u'meters': 
    412                     pass 
     415                    DistanceFromMeters = lambda(d): d 
    413416                elif unit == u'miles': 
    414417                    interval *= 1609.344 
     418                    DistanceFromMeters = lambda(d): d / 1609.344 
    415419                elif unit == u'nautical miles': 
    416420                    interval *= 1852 
     421                    DistanceFromMeters = lambda(d): d / 1852. 
    417422                elif unit == u'yards': 
    418423                    interval *= 0.9144 
     424                    DistanceFromMeters = lambda(d): d / 0.9144 
    419425                else: 
    420426                    raise ValueError(_(u'"%(unit)s" is an unknown unit. Please use days, decimal degrees, feet, hours, kilometers, meters, miles, minutes, nautical miles, seconds, or yards.') % {u'unit': unit}) 
     427            else: 
     428                DistanceFromMeters = lambda(d): d 
    421429 
    422430            # Create the output feature class. 
     
    565573            try: 
    566574                if outputVertexFeatureClass: 
     575                    Logger.Info(_(u'Inserting points for track line vertices into %(output)s.') % {u'output': outputVertexFeatureClass}) 
    567576                    vertexInsertCursor = outputVertexTable.OpenInsertCursor() 
    568577                     
     
    575584 
    576585                        # Read field values for this line. 
     586 
     587                        if gotLine: 
     588                            oldFieldValues = fieldValues  
     589 
     590                            if distanceField is not None: 
     591                                oldFieldValues[distanceField] = DistanceFromMeters(distanceSinceStart) 
     592                            if pointTimeField is not None: 
     593                                oldFieldValues[pointTimeField] = endTime 
     594                            if elapsedField is not None: 
     595                                oldFieldValues[elapsedField] = durationSinceStart 
    577596 
    578597                        fieldValues = {} 
     
    607626                            if newTrackID != trackID and pointsAtLineEnds and trackIsValid and (temporalInterval and durationSincePoint > datetime.timedelta(0) or not temporalInterval and distanceSincePoint > 0) and endX is not None: 
    608627                                Logger.Debug('Track %r: Writing end point' % trackID) 
    609  
    610                                 if distanceField is not None: 
    611                                     fieldValues[distanceField] = distanceSinceStart 
    612                                 if pointTimeField is not None: 
    613                                     fieldValues[pointTimeField] = endTime 
    614                                 if elapsedField is not None: 
    615                                     fieldValues[elapsedField] = durationSinceStart 
    616  
    617                                 cls._InsertPointForLine(endX, endY, insertCursor, destFields, fieldValues, elapsedUnit) 
     628                                cls._InsertPointForLine(endX, endY, insertCursor, destFields, oldFieldValues, elapsedUnit) 
    618629 
    619630                        # If this line is the start of a new track, 
     
    730741                                part = geometry.GetGeometryRef(partIndex) 
    731742 
     743                            # If the caller requested a vertex feature 
     744                            # class, output a point for the first 
     745                            # point of this part. 
     746 
     747                            if outputVertexFeatureClass and part.GetPointCount() >= 2: 
     748                                if distanceField is not None: 
     749                                    fieldValues[distanceField] = DistanceFromMeters(distanceSinceStart) 
     750                                if pointTimeField is not None: 
     751                                    fieldValues[pointTimeField] = currentTime 
     752                                if elapsedField is not None: 
     753                                    fieldValues[elapsedField] = durationSinceStart 
     754 
     755                                cls._InsertPointForLine(part.GetX(0), part.GetY(0), vertexInsertCursor, destFields, fieldValues, elapsedUnit) 
     756 
    732757                            for i in range(1, part.GetPointCount()): 
    733  
    734                                 # If the caller wants points at the 
    735                                 # ends of the track and we have not 
    736                                 # inserted the first point yet, do it. 
    737  
    738                                 if startOfTrack and pointsAtLineEnds: 
    739                                     if distanceField is not None: 
    740                                         fieldValues[distanceField] = distanceSinceStart     # Will always be 0. 
    741                                     if pointTimeField is not None: 
    742                                         fieldValues[pointTimeField] = startTime 
    743                                     if elapsedField is not None: 
    744                                         fieldValues[elapsedField] = durationSinceStart      # Will always be datetime.timedelta(0) 
    745                                          
    746                                     cls._InsertPointForLine(part.GetX(i-1), part.GetY(i-1), insertCursor, destFields, fieldValues, elapsedUnit) 
    747                                  
    748                                 startOfTrack = False 
    749  
    750                                 # Generate points along this part until the remaining interval on this part is less than 
    751                                 # the interval to the next point. 
    752758 
    753759                                currentX = part.GetX(i-1) 
     
    756762                                endY = part.GetY(i) 
    757763 
     764                                # If the caller wants points at the 
     765                                # ends of the track and we have not 
     766                                # inserted the first point yet, do it. 
     767 
     768                                if startOfTrack and pointsAtLineEnds: 
     769                                    if distanceField is not None: 
     770                                        fieldValues[distanceField] = 0. 
     771                                    if pointTimeField is not None: 
     772                                        fieldValues[pointTimeField] = startTime 
     773                                    if elapsedField is not None: 
     774                                        fieldValues[elapsedField] = datetime.timedelta(0) 
     775                                         
     776                                    cls._InsertPointForLine(currentX, currentY, insertCursor, destFields, fieldValues, elapsedUnit) 
     777                                 
     778                                startOfTrack = False 
     779 
     780                                # Generate points along this part until the remaining interval on this part is less than 
     781                                # the interval to the next point. 
     782 
    758783                                while True: 
    759784 
     
    770795                                        # part. 
    771796                                         
    772                                         if distanceToEnd < intervalToNextPoint: 
     797                                        if not pointsAtLineEnds and distanceToEnd < intervalToNextPoint or pointsAtLineEnds and distanceToEnd / intervalToNextPoint < 1.00000001:    # When pointsAtLineEnds is true, avoid placing point very close to the end because one will be put there anyway. 
    773798                                            distanceSincePoint += distanceToEnd 
    774799                                            distanceSinceStart += distanceToEnd 
     
    805830                                        # point. If so, break out of the while loop, so we go on to the next part. 
    806831                                         
    807                                         if distanceToEnd < distanceToNextPoint: 
     832                                        if not pointsAtLineEnds and distanceToEnd < distanceToNextPoint or pointsAtLineEnds and distanceToEnd / distanceToNextPoint < 1.00000001:    # When pointsAtLineEnds is true, avoid placing point very close to the end because one will be put there anyway. 
    808833                                            distanceSincePoint += distanceToEnd 
    809834                                            distanceSinceStart += distanceToEnd 
     
    831856 
    832857                                    if distanceField is not None: 
    833                                         fieldValues[distanceField] = distanceSinceStart 
     858                                        fieldValues[distanceField] = DistanceFromMeters(distanceSinceStart) 
    834859                                    if pointTimeField is not None: 
    835860                                        fieldValues[pointTimeField] = currentTime 
     
    852877                                    if temporalInterval: 
    853878                                        distanceToNextPoint = rate * (intervalToNextPoint.microseconds * 0.000001 + intervalToNextPoint.seconds + intervalToNextPoint.days * 86400.) 
     879 
     880                                # If the caller requested a vertex 
     881                                # feature class, output a point for 
     882                                # the last point of this part. 
     883 
     884                                if outputVertexFeatureClass: 
     885                                    if distanceField is not None: 
     886                                        fieldValues[distanceField] = DistanceFromMeters(distanceSinceStart) 
     887                                    if pointTimeField is not None: 
     888                                        fieldValues[pointTimeField] = currentTime 
     889                                    if elapsedField is not None: 
     890                                        fieldValues[elapsedField] = durationSinceStart 
     891 
     892                                    cls._InsertPointForLine(endX, endY, vertexInsertCursor, destFields, fieldValues, elapsedUnit) 
    854893 
    855894                            if not isMultipart: 
     
    865904 
    866905                        if distanceField is not None: 
    867                             fieldValues[distanceField] = distanceSinceStart + distanceSincePoint 
     906                            fieldValues[distanceField] = DistanceFromMeters(distanceSinceStart) 
    868907                        if pointTimeField is not None: 
    869908                            fieldValues[pointTimeField] = endTime 
    870909                        if elapsedField is not None: 
    871                             fieldValues[elapsedField] = durationSinceStart + durationSincePoint 
     910                            fieldValues[elapsedField] = durationSinceStart 
    872911 
    873912                        cls._InsertPointForLine(endX, endY, insertCursor, destFields, fieldValues, elapsedUnit) 
     
    876915                    del selectCursor 
    877916            finally: 
     917                del insertCursor 
    878918                if vertexInsertCursor is not None: 
    879919                    del vertexInsertCursor 
    880                 del insertCursor 
    881920        except: 
    882921            Logger.LogExceptionAsError() 
     
    26642703 
    26652704AddArgumentMetadata(ArcGISPoints.CreatePointsAlongLines, u'outputVertexFeatureClass', 
    2666     typeMetadata=ArcGISFeatureClassTypeMetadata(canBeNone=True, deleteIfParameterIsTrue=u'overwriteExisting', createParentDirectories=True, mustBeDifferentThanArguments=[u'inputLines, outputFeatureClass']), 
     2705    typeMetadata=ArcGISFeatureClassTypeMetadata(canBeNone=True, deleteIfParameterIsTrue=u'overwriteExisting', createParentDirectories=True, mustBeDifferentThanArguments=[u'inputLines', u'outputFeatureClass']), 
    26672706    description=_( 
    26682707u"""Optional output feature point class to create and populate with 
Note: See TracChangeset for help on using the changeset viewer.