public bool Initialize(ICameraModel camera, int imageWidth, int imageHeight)
{
this._Width = imageWidth;
this._Height = imageHeight;
Item cameraItem = null;
try
{
//Инициализировать камеру
cameraItem = Configuration.Instance.GetItem(camera.Id);
_JpegLiveSource = new JPEGLiveSource(cameraItem); //Исключение если камера не найдена
//SetResolution();
_JpegLiveSource.LiveModeStart = true;
_JpegLiveSource.SetKeepAspectRatio(true, false);
_JpegLiveSource.Width = imageWidth;
_JpegLiveSource.Height = imageHeight;
_JpegLiveSource.KeyFramesOnly = false;
_JpegLiveSource.Init();
_JpegLiveSource.LiveContentEvent += _JpegLiveSource_LiveContentEvent;
//_JpegLiveSource.LiveStatusEvent += _JpegLiveSource_LiveStatusEvent;
return(true);
}
catch (Exception)
{
_JpegLiveSource = null;
cameraItem = null;
return(false);
}
}
/// <summary>
/// saves camera to database
/// </summary>
/// <param name="camera"></param>
public void Save(ICameraModel camera)
{
int max = 0;
ICameraModel del = null;
if (camera.ID > 0)
{
foreach (ICameraModel p in caml)
{
if (p.ID == camera.ID)
{
del = p;
break;
}
}
caml.Remove(del); //Add errorhandling here
}
else
{
foreach (ICameraModel p in caml)
{
if (p.ID > max)
{
max = p.ID;
}
}
camera.ID = max + 1;
}
caml.Add(camera);
}
public ICameraViewModel GetCameraViewModel(ICameraModel mdl)
{
return(new CameraViewModel()
{
Producer = mdl.Producer, Make = mdl.Make
});
}
private IEXIFViewModel SetupISORatingTest(decimal iso, bool setupCamera = true)
{
IEXIFModel exif = ueb.GetEmptyEXIFModel();
AssertNotNull("GetEmptyEXIFModel", exif);
exif.Make = "Canon";
exif.ISOValue = iso;
exif.FNumber = 8;
exif.ExposureTime = 0.008m;
IEXIFViewModel vmdl = ueb.GetEXIFViewModel(exif);
AssertNotNull("GetEXIFViewModel", vmdl);
if (setupCamera)
{
ICameraModel camera = ueb.GetCameraModel("Canon", "EOS 80D");
AssertNotNull("GetCameraModel", camera);
camera.ISOLimitGood = 400;
camera.ISOLimitAcceptable = 800;
vmdl.Camera = ueb.GetCameraViewModel(camera);
}
return(vmdl);
}
public void Save(ICameraModel camera)
{
var output = camera.ID <= 0 ? "Save new Camera" : $"Save Camera model for ID: {camera.ID}";
if (camera == null)
{
throw new ArgumentNullException(nameof(camera));
}
Console.WriteLine(output);
try
{
Conn.Open();
PS.SaveCamera.Parameters["@Cam_ID"].Value = camera.ID <= 0 ? DBNull.Value : (object)camera.ID;
PS.SaveCamera.Parameters["@Producer"].Value = camera.Producer;
PS.SaveCamera.Parameters["@Make"].Value = camera.Make;
PS.SaveCamera.Parameters["@BoughtOn"].Value = camera.BoughtOn;
PS.SaveCamera.Parameters["@Notes"].Value = camera.Notes;
PS.SaveCamera.Parameters["@ISOLimitGood"].Value = camera.ISOLimitGood;
PS.SaveCamera.Parameters["@ISOLimitAcceptable"].Value = camera.ISOLimitAcceptable;
PS.SaveCamera.ExecuteNonQuery();
Conn.Close();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw new Exception(output, e);
}
finally
{
Conn.Close();
}
}
public void SetAudioStreamInPanel(ICameraModel camera, Panel panel)
{
panel.Controls.Add(_audioPlayerControl);
_audioPlayerControl.MicrophoneFQID = (FQID)camera.MicrophoneId;
_audioPlayerControl.Initialize();
_audioPlayerControl.Connect();
}
public CameraViewModel(ICameraModel cm)
{
Producer = cm.Producer;
Make = cm.Make;
ISOLimitAcceptable = cm.ISOLimitAcceptable;
ISOLimitGood = cm.ISOLimitGood;
}
public CameraViewModel(ICameraModel mdl)
{
if (mdl != null)
{
CameraModel = mdl;
}
}
/// <summary>
/// Copies the specified camera, converts field of view/width if necessary.
/// </summary>
/// <param name="source">
/// The source camera.
/// </param>
/// <param name="dest">
/// The destination camera.
/// </param>
public static void CopyTo(this ICameraModel source, Camera dest)
{
var projectionSource = source as IProjectionCameraModel;
var projectionDest = dest as IProjectionCameraModel;
if (projectionSource == null || projectionDest == null)
{
return;
}
projectionDest.LookDirection = projectionSource.LookDirection;
projectionDest.Position = projectionSource.Position;
projectionDest.UpDirection = projectionSource.UpDirection;
var psrc = source as IPerspectiveCameraModel;
var osrc = source as IOrthographicCameraModel;
var pdest = dest as IPerspectiveCameraModel;
var odest = dest as IOrthographicCameraModel;
if (pdest != null)
{
projectionDest.NearPlaneDistance = projectionSource.NearPlaneDistance > 0 ? projectionSource.NearPlaneDistance : 1e-1;
projectionDest.FarPlaneDistance = projectionSource.FarPlaneDistance;
double fov = 45;
if (psrc != null)
{
fov = psrc.FieldOfView;
}
if (osrc != null)
{
double dist = projectionSource.LookDirection.Length;
fov = Math.Atan2(osrc.Width / 2, dist) * (180 / Math.PI);
}
pdest.FieldOfView = fov;
}
if (odest != null)
{
projectionDest.NearPlaneDistance = projectionSource.NearPlaneDistance;
projectionDest.FarPlaneDistance = projectionSource.FarPlaneDistance;
double width = 100;
if (psrc != null)
{
double dist = projectionSource.LookDirection.Length;
width = Math.Tan(psrc.FieldOfView / 180 * Math.PI) * 2 * dist;
}
if (osrc != null)
{
width = osrc.Width;
}
odest.Width = width;
}
}
public void SaveCamera(ICameraModel camera)
{
//TODO: Save Camera to database
var query = "INSERT INTO dbo.CameraModel(Producer, Make, BoughtOn, Notes, ISOLimitAcceptable, ISOLimitGood)"
+ "VALUES(@producer, @make, @boughtOn, @notes, @isoAcc, @isoGood);";
// Create and prepare an SQL statement.
var producerParam =
new SqlParameter("@producer", SqlDbType.Text, 255)
{
Value = camera.Producer
};
var makeParam =
new SqlParameter("@make", SqlDbType.Text, 255)
{
Value = camera.Make
};
var boughtOnParam =
new SqlParameter("@boughtOn", SqlDbType.DateTime)
{
Value = camera.BoughtOn
};
var notesParam = new SqlParameter("@notes", SqlDbType.Text, 255)
{
Value = camera.Notes
};
var isoAccLimit = new SqlParameter("@isoAcc", SqlDbType.Decimal)
{
Value = camera.ISOLimitAcceptable, Precision = 18, Scale = 0
};
var isoGood = new SqlParameter("@isoGood", SqlDbType.Decimal)
{
Value = camera.ISOLimitGood, Precision = 18, Scale = 0
};
using (var connection = new SqlConnection(ConnectionString))
{
connection.Open();
var command = new SqlCommand(null, connection)
{
CommandText = query
};
command.Parameters.Add(producerParam);
command.Parameters.Add(makeParam);
command.Parameters.Add(boughtOnParam);
command.Parameters.Add(notesParam);
command.Parameters.Add(isoAccLimit);
command.Parameters.Add(isoGood);
// Call Prepare after setting the Commandtext and Parameters.
command.Prepare();
// Change parameter values and call ExecuteNonQuery.
command.ExecuteScalar();
connection.Close();
}
}
/// <summary>
/// Показать контрол для одной камеры
/// </summary>
private void ShowVideoControl(ICameraModel camera)
{
_mainPresenter.SetVisible(false);
UserControl videoControl = (UserControl)_videoPresenter.GetView();
videoControl.Dock = DockStyle.Fill;
this.Controls.Add(videoControl);
_videoPresenter.Camera = camera;
}
/// <summary>
/// gets all cameras from database
/// </summary>
/// <returns></returns>
public IEnumerable <ICameraModel> GetCameras()
{
Dictionary <int, CameraModel> newCameras = new Dictionary <int, CameraModel>();
SqlCommand c = new SqlCommand(null, dbc);
c.CommandText = "SELECT ID, Producer, Make, BoughtOn, Notes, ISOLimitGood, ISOLimitAcceptable FROM Cameras";
SqlDataReader dr = c.ExecuteReader();
while (dr.Read())
{
int ID = dr.GetInt32(0);
if (_Cameras.ContainsKey(ID))
{
newCameras.Add(ID, _Cameras[ID]);
}
else
{
newCameras.Add(ID, new CameraModel());
}
ICameraModel cm = newCameras[ID];
cm.ID = ID;
try
{
cm.Producer = dr.GetString(1);
}
catch (SqlNullValueException) { }
try
{
cm.Make = dr.GetString(2);
}
catch (SqlNullValueException) { }
try
{
cm.BoughtOn = dr.GetDateTime(3);
}
catch (SqlNullValueException) { }
try
{
cm.Notes = dr.GetString(4);
}
catch (SqlNullValueException) { }
try
{
cm.ISOLimitGood = dr.GetDecimal(5);
}
catch (SqlNullValueException) { }
try
{
cm.ISOLimitAcceptable = dr.GetDecimal(6);
}
catch (SqlNullValueException) { }
}
dr.Close();
_Cameras = newCameras;
return(_Cameras.Values.ToList());
}
public void mock_dal_should_return_fake_Camera_data_by_ID()
{
IDataAccessLayer dal = ueb.GetDataAccessLayer();
AssertNotNull("GetDataAccessLayer", dal);
ICameraModel obj = dal.GetCamera(1234);
AssertNotNull("dal.GetCamera", obj);
}
/// <summary>
/// ctor with model
/// </summary>
/// <param name="mdl"></param>
public CameraViewModel(ICameraModel mdl)
{
ID = mdl.ID;
Producer = mdl.Producer;
Make = mdl.Make;
BoughtOn = mdl.BoughtOn;
Notes = mdl.Notes;
ISOLimitGood = mdl.ISOLimitGood;
ISOLimitAcceptable = mdl.ISOLimitAcceptable;
}
public void bl_should_return_Camera_by_ID()
{
IBusinessLayer bl = ueb.GetBusinessLayer();
AssertNotNull("GetBusinessLayer", bl);
ICameraModel obj = bl.GetCamera(1234);
AssertNotNull("bl.GetCamera", obj);
}
public void UpdateCamera(ICameraModel cameraModel)
{
using (var connection = new SqlConnection(ConnectionString))
{
connection.Open();
var cmd = new SqlCommand("UPDATE dbo.CameraModel " +
"SET Producer = @producer, Make = @make, BoughtOn = @boughton, Notes = @notes, ISOLimitGood = @isolimitgood, ISOLimitAcceptable = @isolimitacceptable " +
"WHERE ID = @id;", connection);
var ipParam = new SqlParameter("@id", SqlDbType.Int)
{
Value = cameraModel.ID
};
var producerParam = new SqlParameter("@producer", SqlDbType.Text, 255)
{
Value = cameraModel.Producer
};
var makeParam = new SqlParameter("@make", SqlDbType.Text, 255)
{
Value = cameraModel.Make
};
var boughtonParam = new SqlParameter("@boughton", SqlDbType.Date)
{
Value = cameraModel.BoughtOn
};
var notesParam = new SqlParameter("@notes", SqlDbType.Text, 255)
{
Value = cameraModel.Notes
};
var isolimitgoodParam = new SqlParameter("@isolimitgood", SqlDbType.Decimal)
{
Value = cameraModel.ISOLimitGood
};
isolimitgoodParam.Precision = 18;
var isolimitacceptabeParam = new SqlParameter("@isolimitacceptable", SqlDbType.Decimal)
{
Value = cameraModel.ISOLimitAcceptable
};
isolimitacceptabeParam.Precision = 18;
cmd.Parameters.Add(ipParam);
cmd.Parameters.Add(producerParam);
cmd.Parameters.Add(makeParam);
cmd.Parameters.Add(boughtonParam);
cmd.Parameters.Add(notesParam);
cmd.Parameters.Add(isolimitgoodParam);
cmd.Parameters.Add(isolimitacceptabeParam);
cmd.Prepare();
cmd.ExecuteScalar();
connection.Close();
}
}
public ICameraViewModel Build(ICameraModel model)
{
var viewModel = new CameraViewModel
{
TimeZoneInfo = model.TimeZoneInfo,
CameraName = model.CameraName,
CameraIcon = model.CameraIcon
};
return(viewModel);
}
public void CameraViewModel_should_reflect_Model()
{
ICameraModel mdl = ueb.GetCameraModel("Canon", "EOS 80D");
AssertNotNull("GetCameraModel", mdl);
ICameraViewModel vmdl = ueb.GetCameraViewModel(mdl);
AssertNotNull("GetCameraViewModel", vmdl);
AssertEquals("Canon", vmdl.Producer);
AssertEquals("EOS 80D", vmdl.Make);
}
/// <summary>
/// save camera model to database
/// </summary>
/// <param name="camera"></param>
public void Save(ICameraModel camera)
{
if (_Cameras.ContainsKey(camera.ID))
{
UpdateCamera(camera);
}
else
{
InsertCamera(camera);
}
}
/// <summary>
/// Set the camera target point and directions
/// </summary>
/// <param name="camera">
/// The camera.
/// </param>
/// <param name="target">
/// The target.
/// </param>
/// <param name="newLookDirection">
/// The new look direction.
/// </param>
/// <param name="newUpDirection">
/// The new up direction.
/// </param>
/// <param name="animationTime">
/// The animation time.
/// </param>
public static void LookAt(
this ICameraModel camera,
Point3D target,
Vector3D newLookDirection,
Vector3D newUpDirection,
double animationTime)
{
var newPosition = target - newLookDirection;
camera.AnimateTo(newPosition, newLookDirection, newUpDirection, animationTime);
}
public CameraViewModel(ICameraModel mdl)
{
this.cmdl = mdl;
/*
* BoughtOn = cmdl.BoughtOn;
* ID = cmdl.ID;
* Producer = cmdl.Producer;
* Make = cmdl.Make;
* ISOLimitGood = cmdl.ISOLimitGood;
* ISOLimitAcceptable = cmdl.ISOLimitAcceptable;*/
}
private void CreatePresenter()
{
PlaybackPresenter playbackPres = new PlaybackPresenter(new MiniPlayBack());
playbackPres.InitialTime = _view.StartTimePicker.Value;
playbackPres.EndTime = _view.EndTimePicker.Value;
dynamic id = _view.CamerasListView.SelectedItems[0].Tag;
ICameraModel cam = _cameraManager.GetCamera(id);
playbackPres.Camera = cam;
_presToAdd.AddPlayback(playbackPres);
}
public void PictureModel_should_reflect_Camera()
{
IPictureModel mdl = ueb.GetPictureModel("test.jpg");
AssertNotNull("GetPictureModel", mdl);
ICameraModel c = ueb.GetCameraModel("Canon", "EOS 20D");
AssertNotNull("GetCameraModel", c);
mdl.Camera = c;
AssertNotNull("mdl.Camera", mdl.Camera);
AssertEquals(c, mdl.Camera);
}
private ICameraViewModel GetCameraViewModel()
{
ICameraModel mdl = ueb.GetEmptyCameraModel();
AssertNotNull("GetEmptyCameraModel", mdl);
ICameraViewModel vmdl = ueb.GetCameraViewModel(mdl);
AssertNotNull("GetCameraViewModel", vmdl);
return(vmdl);
}
private void SetCameraToSmallView()
{
var c = _activeGroup.Cameras.Keys;;
for (int i = 0; i < c.Count; i++)
{
ICameraModel camera = _cameraManager.GetCamera(c.ElementAt(i));
ISmallVideoPresenter presenter = _smallPresenters[i];
presenter.Disconnect();
presenter.Camera = camera;
presenter.ShowVideo();
}
}
internal void init(ICameraModel model, Func <Vector2> playerModelGetCachedPosition, ILevelBoundsModel levelBounds)
{
// get delegates from the mediator
this.model = model;
this.playerModelGetCachedPosition = playerModelGetCachedPosition;
this.levelBounds = levelBounds;
// initialize camera
camera.orthographicSize = 20;
// zoom on player on start
StartCoroutine(ZoomOnPlayerOnStart());
}
public void CameraViewModel_should_reflect_Model()
{
ICameraModel mdl = ueb.GetCameraModel("Canon", "EOS 80D");
AssertNotNull("GetCameraModel", mdl);
mdl.ISOLimitGood = 400;
mdl.ISOLimitAcceptable = 800;
ICameraViewModel vmdl = ueb.GetCameraViewModel(mdl);
AssertNotNull("GetCameraViewModel", vmdl);
AssertEquals(400, vmdl.ISOLimitGood);
AssertEquals(800, vmdl.ISOLimitAcceptable);
}
public CameraViewModel(ICameraModel mdl)
{
if (mdl == null)
{
return;
}
this.Producer = mdl.Producer;
this.BoughtOn = mdl.BoughtOn;
this.ID = mdl.ID;
this.ISOLimitAcceptable = mdl.ISOLimitAcceptable;
this.ISOLimitGood = mdl.ISOLimitGood;
this.Make = mdl.Make;
this.Notes = mdl.Notes;
}
public CameraViewModel(ICameraModel model)
{
if (model == null)
{
return;
}
ID = model.ID;
Producer = model.Producer;
BoughtOn = model.BoughtOn;
Make = model.Make;
ISOLimitGood = model.ISOLimitGood;
ISOLimitAcceptable = model.ISOLimitAcceptable;
Notes = model.Notes;
}
public void SetVideoStreamInPanelAtTime(ICameraModel camera, Panel videoPanel, DateTime initialTime, DateTime endTime)
{
PrepareControls(videoPanel);
try
{
CloseCurrent();
_newlySelectedItem = Configuration.Instance.GetItem(camera.Id);
_bitmapSource.Item = _newlySelectedItem;
InitBitmap();
SetLoopedTime(initialTime, endTime);
}
catch (Exception ex)
{
EnvironmentManager.Instance.ExceptionDialog("Camera select", ex);
}
}
