def get_info_json(cls, flight_pk): found = LazyGetModelByName( settings.XGDS_IMAGE_IMAGE_SET_MODEL).get().objects.filter( flight__id=flight_pk) result = None if found.exists(): flight = LazyGetModelByName( settings.XGDS_CORE_FLIGHT_MODEL).get().objects.get( id=flight_pk) result = { 'name': settings.XGDS_IMAGE_IMAGE_SET_MONIKER + 's', 'count': found.count(), 'url': reverse('search_map_object_filter', kwargs={ 'modelName': settings.XGDS_IMAGE_IMAGE_SET_MONIKER, 'filter': 'flight__group:%d,flight__vehicle:%d' % (flight.group.pk, flight.vehicle.pk) }) } return result
def get_info_json(cls, flight_pk): found = LazyGetModelByName(cls.get_qualified_model_name()).get().objects.filter(flight__id=flight_pk) result = None if found.exists(): flight = LazyGetModelByName(settings.XGDS_CORE_FLIGHT_MODEL).get().objects.get(id=flight_pk) result = {'name': cls.get_plural_moniker(), 'count': found.count(), 'url': reverse('search_map_object_filter', kwargs={'modelName': cls.get_jsmap_key(), 'filter': 'flight__group:%d,flight__vehicle:%d' % ( flight.group.pk, flight.vehicle.pk)}) } return result
def get_info_json(cls, flight_pk): """ For some reason because of the way this method is used with reflection we have to redefine it.""" found = LazyGetModelByName(cls.get_qualified_model_name()).get().objects.filter(flight__id=flight_pk) result = None if found.exists(): flight = LazyGetModelByName(settings.XGDS_CORE_FLIGHT_MODEL).get().objects.get(id=flight_pk) result = {'name': cls.get_plural_moniker(), 'count': found.count(), 'url': reverse('search_map_object_filter', kwargs={'modelName': cls.get_jsmap_key(), 'filter': 'flight__group:%d,flight__vehicle:%d' % ( flight.group.pk, flight.vehicle.pk)}) } return result
def get_tree_json(cls, parent_class, parent_pk): try: found = LazyGetModelByName( settings.XGDS_IMAGE_IMAGE_SET_MODEL).get().objects.filter( flight__id=parent_pk) result = None if found.exists(): moniker = settings.XGDS_IMAGE_IMAGE_SET_MONIKER + 's' flight = found[0].flight result = [{ "title": moniker, "selected": False, "tooltip": "%s for %s " % (moniker, flight.name), "key": "%s_%s" % (flight.uuid, moniker), "data": { "json": reverse('xgds_map_server_objectsJson', kwargs={ 'object_name': 'XGDS_IMAGE_IMAGE_SET_MODEL', 'filter': 'flight__pk:' + str(flight.pk) }), "sseUrl": "", "type": 'MapLink', } }] return result except ObjectDoesNotExist: return None
def callPextantAjax(request, planId, clear=0): """ Call Pextant over Ajax and either return the modified plan with success message, or return error message. """ PLAN_MODEL = LazyGetModelByName(settings.XGDS_PLANNER2_PLAN_MODEL) response = {} try: plan = PLAN_MODEL.get().objects.get(pk=planId) plan = pextantHarness.clearSegmentGeometry(plan) response["plan"] = plan.jsonPlan if clear: response["msg"] = "Sextant route cleared." response["status"] = True status = 200 else: optimize = str(request.POST['optimize']) maxSlope = float(request.POST['slope']) post_extent = request.POST['extent'] if post_extent: extent = [float(val) for val in (str(post_extent).split(','))] plan = pextantHarness.callPextant(request, plan, optimize, maxSlope, extent) response["plan"] = plan.jsonPlan response["msg"] = "Sextant has calculated a new route." response["status"] = True status = 200 except Exception, e: traceback.print_exc() response["msg"] = str(e) response["status"] = False status = 406
def planImportXPJson(request): PLAN_MODEL = LazyGetModelByName(settings.XGDS_PLANNER2_PLAN_MODEL) try: form = UploadXPJsonForm(request.POST, request.FILES) if form.is_valid(): planUuid = form.cleaned_data['planUuid'] try: plan = PLAN_MODEL.get().objects.get(uuid=planUuid) except: return HttpResponse(json.dumps({'Success':"False", 'responseText': 'Wrong UUID, plan not found'}), content_type='application/json', status=406) incoming = request.FILES['file'] newJson = handle_uploading_xpjson(incoming) if (len(newJson) > 0): newJsonObj = json.loads(newJson, 'UTF-8') foundUuid = newJsonObj['uuid'] if (foundUuid != planUuid): return HttpResponse(json.dumps({'Success':"False", 'responseText': 'Loaded JSON is for a different plan; UUID of plans do not match.'}), content_type='application/json', status=406) isValid = validateJson(newJsonObj) if isValid == True: updateJson(plan, newJsonObj) return HttpResponse(json.dumps({'Success':"True"})) else: return HttpResponse(json.dumps({'Success':"False", 'responseText': isValid}), content_type='application/json', status=406) else: return HttpResponse(json.dumps({'Success':"False", 'responseText': 'JSON Empty'}), content_type='application/json', status=406) except Exception: traceback.print_exc() exc_type, exc_value, exc_traceback = sys.exc_info() return HttpResponse(json.dumps({'Success':"False", 'responseText': exc_value['message']}), content_type='application/json', status=406)
def buildTextAnnotationQuery(cls, search_keywords): """ Build a query that will search for an image set that is pointed to by a text annotation containing keyword :param search_keywords: keywords to search for in the format keyword and keyword or keyword etc :return: the found list of pks """ master_query = LazyGetModelByName( settings.XGDS_IMAGE_TEXT_ANNOTATION_MODEL).get().objects.all() counter = 0 last_query = None keyword_query = None while counter < len(search_keywords): if counter % 2 == 0: last_query = Q( **{'content__icontains': search_keywords[counter]}) else: if not keyword_query: keyword_query = last_query else: join_type = search_keywords[counter] if join_type == 'and': keyword_query &= last_query else: keyword_query |= last_query counter += 1 if not keyword_query: keyword_query = last_query result = master_query.filter(keyword_query) image_ids = result.values_list('image_id', flat=True) return list(image_ids)
def getInstrumentDataCsvResponse(request, productModel, productPk): INSTRUMENT_DATA_PRODUCT_MODEL = LazyGetModelByName(productModel) dataProduct = get_object_or_404(INSTRUMENT_DATA_PRODUCT_MODEL.get(), pk=productPk) filename, dataframe = dataProduct.getInstrumentDataCsv() response = HttpResponse(content_type='text/csv') response['Content-Disposition'] = 'attachment; filename=' + filename dataframe.to_csv(response, index=False) return response
def getActiveFlights(vehicle=None): ACTIVE_FLIGHTS_MODEL = LazyGetModelByName(settings.XGDS_PLANNER2_ACTIVE_FLIGHT_MODEL) if not vehicle: return ACTIVE_FLIGHTS_MODEL.get().objects.all() else: # filter by vehicle return ACTIVE_FLIGHTS_MODEL.get().objects.filter(flight__vehicle=vehicle)
def saveUpdatedInstrumentData(request, instrument_name, pk): """ Updates instrument data on save. """ if request.method == 'POST': mapDict = settings.XGDS_MAP_SERVER_JS_MAP[instrument_name] INSTRUMENT_MODEL = LazyGetModelByName(mapDict['model']) dataProduct = INSTRUMENT_MODEL.get().objects.get(pk=pk) # get existing data. if 'edit_form_class' in mapDict: form = getFormByName(mapDict['edit_form_class'])(request.POST, request.FILES) else: form = BasaltInstrumentDataForm(request.POST, request.FILES) try: form.is_valid() except: pass for key in form.changed_data: value = form.cleaned_data[key] if not hasattr(value, 'read'): if not isinstance(value, datetime.datetime): setattr(dataProduct, key, value) else: form.handleFileUpdate(dataProduct, key) # save the update info into the model. # postDict = request.POST.dict() # dataProduct.name = postDict['name'] # dataProduct.description = postDict['description'] # dataProduct.minerals = postDict['minerals'] # resourceId = postDict['resource'] # if resourceId: # resource = BasaltResource.objects.get(id=resourceId) # dataProduct.resource = resource dataProduct.acquisition_time = form.cleaned_data['dataCollectionTime'] if (('lat' in form.cleaned_data) and ('lon' in form.cleaned_data)) or ('alt' in form.cleaned_data): editInstrumentDataPosition(dataProduct, form.cleaned_data['lat'], form.cleaned_data['lon'], form.cleaned_data['alt']) dataProduct.save() messages.success(request, 'Instrument data successfully saved!') return HttpResponseRedirect( reverse('search_map_single_object', kwargs={ 'modelPK': pk, 'modelName': instrument_name }))
def initializeLetter(self, dateprefix): GROUP_FLIGHT_MODEL = LazyGetModelByName( settings.XGDS_PLANNER2_GROUP_FLIGHT_MODEL) try: last = GROUP_FLIGHT_MODEL.get().objects.filter( name__startswith=dateprefix).order_by('name').last() self.fields['prefix'].initial = chr(ord(last.name[-1]) + 1) except: self.fields['prefix'].initial = 'A'
def mapJsonPlan(request, uuid): PLAN_MODEL = LazyGetModelByName(settings.XGDS_PLANNER2_PLAN_MODEL) try: plan = PLAN_MODEL.get().objects.get(uuid=uuid) json_data = json.dumps([plan.toMapDict()], indent=4) return HttpResponse(content=json_data, content_type="application/json") except: return HttpResponse(content={}, content_type="application/json")
def mapJsonPosition(request, id): POSITION_MODEL = LazyGetModelByName(settings.GEOCAM_TRACK_POSITION_MODEL) try: position = POSITION_MODEL.get().objects.get(pk=id) json_data = json.dumps([position.toMapDict()], cls=DatetimeJsonEncoder) return HttpResponse(content=json_data, content_type="application/json") except: return HttpResponse(content={}, content_type="application/json")
def mapJsonTrack(request, uuid, downsample=False): TRACK_MODEL = LazyGetModelByName(settings.GEOCAM_TRACK_TRACK_MODEL) try: track = TRACK_MODEL.get().objects.get(uuid=uuid) json_data = json.dumps([track.toMapDict(downsample)], cls=DatetimeJsonEncoder) return HttpResponse(content=json_data, content_type="application/json") except: traceback.print_exc() return HttpResponse(content={}, content_type="application/json")
class BasaltInstrumentDataForm(ImportInstrumentDataForm): INSTRUMENT_MODEL = LazyGetModelByName( settings.XGDS_INSTRUMENT_INSTRUMENT_MODEL) instrument = InstrumentModelChoiceField( INSTRUMENT_MODEL.get().objects.all(), widget=forms.HiddenInput()) name = forms.CharField(required=False, label="Name") description = forms.CharField(widget=forms.Textarea, label="Description", required=False) minerals = forms.CharField(widget=forms.Textarea, label="Minerals", required=False)
def check_data_exists(filename, timestamp, exif): """ See if there is already identical data :return: True if it already exists, false otherwise """ # get short filename tokens = filename.split('/') shortname = tokens[len(tokens) - 1] cameraId = getCameraByExif(exif) if cameraId is None: found = LazyGetModelByName( settings.XGDS_IMAGE_IMAGE_SET_MODEL).get().objects.filter( name=shortname, acquisition_time=timestamp) else: found = LazyGetModelByName( settings.XGDS_IMAGE_IMAGE_SET_MODEL).get().objects.filter( name=shortname, acquisition_time=timestamp, camera_id=cameraId) if found: return True return False
def editInstrumentData(request, instrument_name, pk): """ Renders instrument data edit page -- if data exists, displays the existing data. """ mapDict = settings.XGDS_MAP_SERVER_JS_MAP[instrument_name] INSTRUMENT_MODEL = LazyGetModelByName(mapDict['model']) dataProduct = INSTRUMENT_MODEL.get().objects.get(pk=pk) jsonDict = dataProduct.toMapDict() # get existing data. if 'edit_form_class' in mapDict: form = getFormByName(mapDict['edit_form_class'])(initial=jsonDict) else: form = BasaltInstrumentDataForm(initial=jsonDict) form.editingSetup(dataProduct) # convert to local time. utcTime = dataProduct.acquisition_time timezone = dataProduct.acquisition_timezone acquisitionTime = utcToTimeZone(utcTime, timezone) acquisitionTime = acquisitionTime.strftime('%m/%d/%Y %H:%M') form.fields['dataCollectionTime'].initial = acquisitionTime form.fields['timezone'].initial = timezone # hide the two file fields # form.fields['portableDataFile'].widget = forms.HiddenInput() # form.fields['manufacturerDataFile'].widget = forms.HiddenInput() # updateInstrumentDataUrl = reverse('instrument_data_update', kwargs={ 'instrument_name': instrument_name, 'pk': pk }) return render( request, 'xgds_instrument/editInstrumentData.html', { 'form': form, 'instrument_name': instrument_name, 'dataProductJson': json.dumps(jsonDict, cls=DatetimeJsonEncoder), 'updateInstrumentDataUrl': updateInstrumentDataUrl, 'manufacturer_data_file_url': dataProduct.manufacturer_data_file_url, 'portable_data_file_url': dataProduct.portable_data_file_url }, )
def initializeVehicleChoices(self): CHOICES = [] VEHICLE_MODEL = LazyGetModelByName( settings.XGDS_PLANNER2_VEHICLE_MODEL) if (VEHICLE_MODEL.get().objects.count() > 0): for vehicle in VEHICLE_MODEL.get().objects.all().order_by('name'): CHOICES.append((vehicle.name, vehicle.name)) if len(CHOICES) == 1: initial = [c[0] for c in CHOICES] else: initial = None result = forms.MultipleChoiceField( choices=CHOICES, widget=forms.CheckboxSelectMultiple(attrs={"checked": ""}), required=False, initial=initial) return result
def save(self, commit=True): instance = super(ImportInstrumentDataForm, self).save(commit=False) if (('lat' in self.changed_data) and ('lon' in self.changed_data)) or ('alt' in self.changed_data): if instance.user_position is None: LOCATION_MODEL = LazyGetModelByName(settings.GEOCAM_TRACK_PAST_POSITION_MODEL) instance.user_position = LOCATION_MODEL.get().objects.create(serverTimestamp = datetime.datetime.now(pytz.utc), timestamp = instance.acquisition_time, latitude = self.cleaned_data['lat'], longitude = self.cleaned_data['lon'], altitude = self.cleaned_data['alt']) else: instance.user_position.latitude = self.cleaned_data['lat'] instance.user_position.longitude = self.cleaned_data['lon'] instance.user_position.altitude = self.cleaned_data['alt'] instance.user_position.save() if commit: instance.save() return instance
def get_tree_json(cls, parent_class, parent_pk): """ For some reason because of the way this method is used with reflection we have to redefine it.""" try: found = LazyGetModelByName(cls.get_qualified_model_name()).get().objects.filter(flight__id=parent_pk) result = None if found.exists(): moniker = cls.get_plural_moniker() flight = found[0].flight result = [{"title": moniker, "selected": False, "tooltip": "%s for %s " % (moniker, flight.name), "key": "%s_%s" % (flight.uuid, moniker), "data": {"json": reverse('xgds_map_server_objectsJson', kwargs={'object_name': cls.get_object_name(), 'filter': 'flight__pk:' + str(flight.pk)}), "sseUrl": "", "type": 'MapLink', } }] return result except ObjectDoesNotExist: return None
def editInstrumentDataPosition(dataProduct, newLatitude, newLongitude, newAltitude): cleanLatitude = cleanValue(newLatitude) cleanLongitude = cleanValue(newLongitude) cleanAltitude = cleanValue(newAltitude) if not newLatitude or not newLongitude: return ''' create or update the user position for an instrument data reading ''' if cleanLatitude != dataProduct.lat or cleanLongitude != dataProduct.lon or cleanAltitude != dataProduct.alt: if dataProduct.user_position is None: LOCATION_MODEL = LazyGetModelByName(settings.GEOCAM_TRACK_PAST_POSITION_MODEL) dataProduct.user_position = LOCATION_MODEL.get().objects.create(serverTimestamp = datetime.datetime.now(pytz.utc), timestamp = dataProduct.acquisition_time, latitude = cleanLatitude, longitude = cleanLongitude, altitude = cleanAltitude) else: dataProduct.user_position.latitude = cleanLatitude dataProduct.user_position.longitude = cleanLongitude dataProduct.user_position.altitude = cleanAltitude dataProduct.user_position.save() dataProduct.save()
def test_frame_grab_and_insert_database(self): """ Test grabbing a video frame and inserting it into the CouchDB """ grab_time_str = '20180902 22:58:52' start_time_str = '20180902 22:58:45' vehicle_name = 'Generic Vehicle' response = self.client.post( reverse('grab_frame_save_image'), { 'path': xgds_videoTest.filepath, 'start_time': start_time_str, 'grab_time': grab_time_str, 'vehicle': vehicle_name, 'camera': 'Hercules', 'username': '******', 'filename_prefix': 'test_grab' }) shortname = 'test_grab_20180902 22:58:52.png' found = LazyGetModelByName( settings.XGDS_IMAGE_IMAGE_SET_MODEL).get().objects.get( name=shortname) with open(xgds_videoTest.ref_2, 'rb') as f: reference_bytes_2 = f.read() f.close() # found is an ImageSet, get its raw image bytes raw_image = found.getRawImage() raw_image_file = raw_image.file found_bytes = raw_image_file.read() raw_image_file.close() equals_reference = (found_bytes == reference_bytes_2) self.assertTrue(equals_reference)
def get_info_json(cls, flight_pk): found = NirvssSpectrometerDataProduct.objects.filter( flight__id=flight_pk) result = None if found.exists(): flight = LazyGetModelByName( settings.XGDS_CORE_FLIGHT_MODEL).get().objects.get( id=flight_pk) result = { 'name': 'NIRVSS Spectra', 'count': found.count(), 'url': reverse('search_map_object_filter', kwargs={ 'modelName': 'Spectrometer', 'filter': 'flight__group:%d,flight__vehicle:%d' % (flight.group.pk, flight.vehicle.pk) }) } return result
def executions(self): return LazyGetModelByName( settings.XGDS_PLANNER_PLAN_EXECUTION_MODEL).get().objects.filter( plan=self)
# # Unless required by applicable law or agreed to in writing, software distributed # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR # CONDITIONS OF ANY KIND, either express or implied. See the License for the # specific language governing permissions and limitations under the License. # __END_LICENSE__ from django.conf import settings from django.utils import timezone from django.contrib.contenttypes.models import ContentType from geocamUtil.loader import LazyGetModelByName from geocamUtil.UserUtil import getUserByUsername from xgds_notes2.models import LocatedNote, Role, Location NOTE_MODEL = LazyGetModelByName(settings.XGDS_NOTES_NOTE_MODEL) """ Utility methods for various importers """ def link_sample_and_image(sample, image): """ Add a note to link a sample to an image :param sample: the sample :param image: the image :return: the new saved note """ content = 'Sample %s' % sample.name return add_note_to_object(content, image, sample.place)
from geocamUtil.loader import getModelByName from geocamUtil.datetimeJsonEncoder import DatetimeJsonEncoder from geocamUtil import TimeUtil from geocamUtil.models.UuidField import makeUuid from geocamUtil.loader import LazyGetModelByName, getClassByName from geocamUtil.models.managers import ModelCollectionManager from geocamTrack.utils import getClosestPosition from PIL import Image from io import BytesIO from cStringIO import StringIO import base64 IMAGE_SET_MODEL = LazyGetModelByName(settings.XGDS_IMAGE_IMAGE_SET_MODEL) SINGLE_IMAGE_MODEL = LazyGetModelByName(settings.XGDS_IMAGE_SINGLE_IMAGE_MODEL) TRACK_MODEL = LazyGetModelByName(settings.GEOCAM_TRACK_TRACK_MODEL) POSITION_MODEL = LazyGetModelByName(settings.GEOCAM_TRACK_PAST_POSITION_MODEL) XGDS_CORE_VEHICLE_MODEL = LazyGetModelByName(settings.XGDS_CORE_VEHICLE_MODEL) XGDS_IMAGE_TEMPLATE_LIST = list(settings.XGDS_MAP_SERVER_HANDLEBARS_DIRS) XGDS_IMAGE_TEMPLATE_LIST = XGDS_IMAGE_TEMPLATE_LIST + settings.XGDS_CORE_TEMPLATE_DIRS[ settings.XGDS_IMAGE_IMAGE_SET_MODEL] ARROW_ANNOTATION_MODEL = LazyGetModelByName( settings.XGDS_IMAGE_ARROW_ANNOTATION_MODEL) ELLIPSE_ANNOTATION_MODEL = LazyGetModelByName( settings.XGDS_IMAGE_ELLIPSE_ANNOTATION_MODEL) RECTANGLE_ANNOTATION_MODEL = LazyGetModelByName( settings.XGDS_IMAGE_RECTANGLE_ANNOTATION_MODEL)