public void OnMethodInvokeBase(MethodInterceptionArgs args)
{
var methodStrategy = this.MethodAttributes[args.Method.Name];
IDisposable implicitOpertaion = null;
ITrackedObject stackPeek = StackTrace.StackPeek() as ITrackedObject;
if (methodStrategy == MethodSnapshotStrategy.Always ||
(methodStrategy == MethodSnapshotStrategy.Auto && (stackPeek == null || !ReferenceEquals(stackPeek.Tracker, this.ThisTracker))))
{
implicitOpertaion = this.ThisTracker.StartImplicitOperation();
}
try
{
StackTrace.PushOnStack(args.Instance);
args.Proceed();
}
finally
{
StackTrace.PopFromStack();
if (implicitOpertaion != null)
{
implicitOpertaion.Dispose();
}
}
}
public void OnMethodInvokeBase(MethodInterceptionArgs args)
{
MethodInfo methodInfo = (MethodInfo)args.Method;
if (methodInfo.IsGenericMethod)
{
methodInfo = methodInfo.GetGenericMethodDefinition();
}
var methodDescriptor = this.MethodAttributes[new MemberInfoIdentity(methodInfo)];
IDisposable operationScope = null;
ITrackedObject stackPeek = StackTrace.StackPeek() as ITrackedObject;
if (methodDescriptor.MethodOperationStrategy == MethodOperationStrategy.Always ||
(methodDescriptor.MethodOperationStrategy == MethodOperationStrategy.Auto &&
(stackPeek == null || !ReferenceEquals(stackPeek.Tracker, this.ThisTracker))))
{
operationScope = this.ThisTracker.StartImplicitOperationScope(string.Format(this.MethodOperationStringFormat, methodDescriptor.OperationName ?? args.Method.Name));
}
try
{
StackTrace.PushOnStack(args.Instance);
args.Proceed();
}
finally
{
StackTrace.PopFromStack();
if (operationScope != null)
{
operationScope.Dispose();
}
}
}
internal void DetachFromAggregate(object oldValue, bool enableTrackingOnTrackerCreation)
{
ITrackedObject trackedObject = (ITrackedObject)oldValue;
AggregateTracker newTracker = new AggregateTracker(trackedObject, enableTrackingOnTrackerCreation);
newTracker.AssociateWithParent(this.ParentTracker);
trackedObject.SetTracker(newTracker);
}
internal void AttachToAggregate(object newValue)
{
ITrackedObject trackedObject = (ITrackedObject)newValue;
if (trackedObject.Tracker == null || ((AggregateTracker)trackedObject.Tracker).OperationsCount != 0)
{
throw new ArgumentException("attaching modified object to aggregate is not supported");
}
trackedObject.SetTracker(this);
}
public void _HandleResult(JToken value)
{
Utility._FixObjectPathIfNecessary(this.m_clientObject, value);
if (value != null &&
!OfficeExtension.Utility._IsNullOrUndefined(value[Constants.ReferenceId]))
{
ITrackedObject trackedObject = this.m_clientObject as ITrackedObject;
if (trackedObject != null)
{
trackedObject._ReferenceId = value[Constants.ReferenceId].Value <string>();
}
}
}
public void Add(ClientObject clientObject)
{
ITrackedObject trackedObj = clientObject as ITrackedObject;
if (trackedObj != null)
{
if (string.IsNullOrEmpty(trackedObj._ReferenceId))
{
trackedObj._KeepReference();
ActionFactory.CreateInstantiateAction(this.m_context, clientObject);
}
}
}
private static void SetUserProperty(ITrackedObject obj, string property)
{
if (string.IsNullOrEmpty(property))
{
return;
}
IMemberInfo member = XafTypesInfo.Instance.FindTypeInfo(obj.GetType()).FindMember(property);
if (member == null)
{
throw new InvalidPropertyPathException(string.Format("The {0} property does not existing within the {1} type", property, obj.GetType().Name));
}
member.SetValue(obj, obj.Session.GetObjectByKey(SecuritySystem.CurrentUser.GetType(), SecuritySystem.CurrentUserId));
}
internal BaseTracker(List<TrackedObjectConfig> measuringStars)
{
if (measuringStars.Count > 4)
throw new NotSupportedException("Only up to 4 tracked objects are supported by this Tracker.");
m_TrackedObjectsConfig = measuringStars;
for (int i = 0; i < m_TrackedObjectsConfig.Count; i++)
{
var trackedObject = new TrackedObjectLight((byte) i, m_TrackedObjectsConfig[i]);
m_TrackedObjects.Add(trackedObject);
if (m_TrackedObjectsConfig[i].TrackingType == TrackingType.OccultedStar)
m_OccultedStar = trackedObject;
}
m_IsFullDisappearance = LightCurveReductionContext.Instance.FullDisappearance;
m_IsFieldRotation = LightCurveReductionContext.Instance.FieldRotation;
}
internal BaseTracker(List <TrackedObjectConfig> measuringStars)
{
if (measuringStars.Count > 4)
{
throw new NotSupportedException("Only up to 4 tracked objects are supported by this Tracker.");
}
m_TrackedObjectsConfig = measuringStars;
for (int i = 0; i < m_TrackedObjectsConfig.Count; i++)
{
var trackedObject = new TrackedObjectLight((byte)i, m_TrackedObjectsConfig[i]);
m_TrackedObjects.Add(trackedObject);
if (m_TrackedObjectsConfig[i].TrackingType == TrackingType.OccultedStar)
{
m_OccultedStar = trackedObject;
}
}
m_IsFullDisappearance = LightCurveReductionContext.Instance.FullDisappearance;
m_IsFieldRotation = LightCurveReductionContext.Instance.FieldRotation;
}
public void Remove(ClientObject clientObject)
{
if (this.m_context._RootObject == null)
{
return;
}
ITrackedObject trackedObject = clientObject as ITrackedObject;
if (trackedObject == null)
{
return;
}
string referenceId = trackedObject._ReferenceId;
if (string.IsNullOrEmpty(referenceId))
{
return;
}
ActionFactory._CreateMethodAction(this.m_context, this.m_context._RootObject, "_RemoveReference", OperationType.Read, new object[] { referenceId });
}
public static void OnSaving(ITrackedObject obj, string modifiedbyproperty)
{
obj.ModifiedOn = DateTime.Now;
SetUserProperty(obj, modifiedbyproperty);
}
public static void AfterConstruction(ITrackedObject obj, string createdbyproperty)
{
obj.CreatedOn = DateTime.Now;
SetUserProperty(obj, createdbyproperty);
}
private void MeasureTrackedObject2(
ITrackedObject trackedObject,
MeasurementsHelper measurer,
TangraConfig.PreProcessingFilter filter,
bool synchronise,
List<ITrackedObject> objectsInGroup,
float refinedFWHM,
float averageFWHM)
{
IImagePixel center = trackedObject.Center;
int areaSize = 17;
if ((objectsInGroup != null && objectsInGroup.Count > 1) || LightCurveReductionContext.Instance.NoiseMethod == TangraConfig.BackgroundMethod.Background3DPolynomial)
// for double PSF fits and/or 3d polynomial background fits we need the largest area
areaSize = 35;
IImagePixel[] groupCenters = new IImagePixel[0];
float[] aperturesInGroup = new float[0];
if (objectsInGroup != null && objectsInGroup.Count > 1)
{
groupCenters = new IImagePixel[objectsInGroup.Count];
aperturesInGroup = new float[objectsInGroup.Count];
for (int i = 0; i < objectsInGroup.Count; i++)
{
groupCenters[i] = objectsInGroup[i].Center;
aperturesInGroup[i] = objectsInGroup[i].OriginalObject.ApertureInPixels;
}
}
int areaDigitalFilterEdge = 0;
if (LightCurveReductionContext.Instance.DigitalFilter != TangraConfig.PreProcessingFilter.NoFilter)
areaDigitalFilterEdge = 2; // The extra 2 pixels will be cut after the filter is applied before the measurement
int centerX = (int)Math.Round(center.XDouble);
int centerY = (int)Math.Round(center.YDouble);
uint[,] data = m_VideoController.GetCurrentAstroImage(false).GetMeasurableAreaPixels(centerX, centerY, areaSize + areaDigitalFilterEdge);
uint[,] backgroundPixels = m_VideoController.GetCurrentAstroImage(false).GetMeasurableAreaPixels(centerX, centerY, 35 + areaDigitalFilterEdge);
float msrX0 = (float)trackedObject.Center.XDouble;
float msrY0 = (float)trackedObject.Center.YDouble;
var measuredObject = new LCMeasurement()
{
CurrFrameNo = (uint) m_CurrFrameNo,
CurrFileName = m_CurrFileName,
TargetNo = (byte) trackedObject.TargetNo,
X0 = msrX0,
Y0 = msrY0,
PixelDataX0 = centerX,
PixelDataY0 = centerY,
OSDTimeStamp = m_OCRedTimeStamp,
FlagsDWORD = trackedObject.GetTrackingFlags()
};
IMeasurableObject measurableObject = (IMeasurableObject)trackedObject;
NotMeasuredReasons rv = MeasureObject(
center,
data,
backgroundPixels,
m_VideoController.VideoBitPix,
measurer,
filter,
LightCurveReductionContext.Instance.ReductionMethod,
LightCurveReductionContext.Instance.PsfQuadratureMethod,
TangraConfig.Settings.Photometry.PsfFittingMethod,
trackedObject.OriginalObject.ApertureInPixels,
refinedFWHM,
averageFWHM,
measurableObject,
groupCenters,
aperturesInGroup,
LightCurveReductionContext.Instance.FullDisappearance);
measuredObject.SetIsMeasured(rv);
uint[,] pixelsToSave = trackedObject.IsOffScreen
? new uint[35, 35]
// As the background may have been pre-processed for measuring, we need to take another copy for saving in the file
: m_VideoController.GetCurrentAstroImage(false).GetMeasurableAreaPixels(centerX, centerY, 35);
bool lockTaken = false;
if (synchronise)
m_WriterLock.TryEnter(ref lockTaken);
try
{
uint flags = trackedObject.GetTrackingFlags();
measuredObject.TotalReading = (uint)Math.Round(measurer.TotalReading);
measuredObject.TotalBackground = (uint)Math.Round(measurer.TotalBackground);
measuredObject.PixelData = pixelsToSave; /* save the original non filtered data */
measuredObject.FlagsDWORD |= flags;
measuredObject.ApertureX = measurer.XCenter;
measuredObject.ApertureY = measurer.YCenter;
measuredObject.ApertureSize = measurer.Aperture;
m_LastTotalReading[trackedObject.TargetNo] = measuredObject.TotalReading;
m_LastTotalBackground[trackedObject.TargetNo] = measuredObject.TotalBackground;
m_LastApertureX[trackedObject.TargetNo] = measuredObject.ApertureX;
m_LastApertureY[trackedObject.TargetNo] = measuredObject.ApertureY;
m_LastApertureSize[trackedObject.TargetNo] = measuredObject.ApertureSize;
m_LastOCRedTimeStamp[trackedObject.TargetNo] = measuredObject.OSDTimeStamp;
LCFile.SaveOnTheFlyMeasurement(measuredObject);
}
finally
{
if (synchronise && lockTaken)
m_WriterLock.Exit();
}
}
public static RestorePointToken SetRestorePoint(object trackedObject, string name = null)
{
ITrackedObject to = CheckObject(trackedObject);
return(((AggregateTracker)to.Tracker).AddRestorePoint(name));
}
public Field(Size size, ITrackedObject target)
{
this.Size = size;
this.ObservationTarget = target;
}
public static object GetAggregateRoot(object trackedObject)
{
ITrackedObject to = CheckObject(trackedObject);
return(((AggregateTracker)to.Tracker).AggregateRoot);
}
public static bool RestorePointExists(object trackedObject, RestorePointToken restorePoint)
{
ITrackedObject to = CheckObject(trackedObject);
return(((AggregateTracker)to.Tracker).RestorePointExists(restorePoint));
}
public static void RedoTo(object trackedObject, string name)
{
ITrackedObject to = CheckObject(trackedObject);
((AggregateTracker)to.Tracker).RedoTo(name);
}
public static void RedoTo(object trackedObject, RestorePointToken token)
{
ITrackedObject to = CheckObject(trackedObject);
((AggregateTracker)to.Tracker).RedoTo(token);
}
public static bool CanStopTracking(object trackedObject)
{
ITrackedObject to = CheckObject(trackedObject);
return(((AggregateTracker)to.Tracker).CanStopTracking());
}
public static void StopTracking(object trackedObject)
{
ITrackedObject to = CheckObject(trackedObject);
((AggregateTracker)to.Tracker).StopTracking();
}
public static void Track(object trackedObject)
{
ITrackedObject to = CheckObject(trackedObject);
((AggregateTracker)to.Tracker).Track();
}
public static void OnDeleting(ITrackedObject obj, string deletedbyproperty)
{
obj.DeletedOn = DateTime.Now;
SetUserProperty(obj, deletedbyproperty);
}
public TrackedObjectGroup(ITrackedObject[] group, bool isFullDisappearance)
{
m_IsFullDisappearance = isFullDisappearance;
m_ObjectGroup.AddRange(group);
IsSingleObject = m_ObjectGroup.Count == 1;
if (IsSingleObject)
{
SingleObject = (TrackedObjectLight)m_ObjectGroup[0];
BrigherOriginalObject = m_ObjectGroup[0].OriginalObject;
ContainsOcultedStar = SingleObject.OriginalObject.IsOcultedStar();
m_LastDeltaX = double.NaN;
m_LastDeltaY = double.NaN;
}
else
{
if (m_ObjectGroup[0].OriginalObject.Gaussian.IMax > m_ObjectGroup[1].OriginalObject.Gaussian.IMax)
{
BrigherOriginalObject = m_ObjectGroup[0].OriginalObject;
m_BrighterObjectIndex = 0;
m_NonOccultedObjectIndex = m_ObjectGroup[0].OriginalObject.IsOcultedStar() ? 1 : 0;
}
else
{
BrigherOriginalObject = m_ObjectGroup[1].OriginalObject;
m_BrighterObjectIndex = 1;
m_NonOccultedObjectIndex = m_ObjectGroup[1].OriginalObject.IsOcultedStar() ? 0 : 1;
}
ContainsOcultedStar =
m_ObjectGroup[0].OriginalObject.IsOcultedStar() ||
m_ObjectGroup[1].OriginalObject.IsOcultedStar();
m_LastDeltaX = m_ObjectGroup[0].LastKnownGoodPosition.XDouble - m_ObjectGroup[1].LastKnownGoodPosition.XDouble;
m_LastDeltaY = m_ObjectGroup[0].LastKnownGoodPosition.YDouble - m_ObjectGroup[1].LastKnownGoodPosition.YDouble;
}
TrackLater = m_IsFullDisappearance && ContainsOcultedStar;
m_CurrentXVector = double.NaN;
m_CurrentYVector = double.NaN;
}
public static IDisposable StartAtomicOperation(object trackedObject, string name)
{
ITrackedObject to = CheckObject(trackedObject);
return(((AggregateTracker)to.Tracker).StartAtomicOperation(name));
}
