예제 #1
0
        public static CameraDto ToCameraDto(this Camera camera)
        {
            var cameraDto = new CameraDto();

            cameraDto.TargetDistance = (camera.Target - camera.Frame.Offset).Length;

            cameraDto.Frame = camera.Frame.ToCardanFrame().ToCardanFrameDto();

            return(cameraDto);
        }
예제 #2
0
        static Camera GetCamera(CameraDto dto)
        {
            var cameraType = Assembly.GetAssembly(typeof(Camera))
                             .GetTypes()
                             .Where(t => t.Name.ToLower() == (dto.Type + "Camera").ToLower())
                             .FirstOrDefault();

            var camera = Mapper.Map(dto, dto.GetType(), cameraType);

            return(camera as Camera);
        }
예제 #3
0
        public static Camera MapApiToDomain(CameraDto input)
        {
            Camera output = new Camera(input.HSize, input.VSize, input.FieldOfView);

            output.SetViewTransformation(
                new Vector3(input.From.X, input.From.Y, input.From.Z).AsPoint(),
                new Vector3(input.To.X, input.To.Y, input.To.Z).AsPoint(),
                new Vector3(input.Up.X, input.Up.Y, input.Up.Z).AsVector()
                );

            return(output);
        }
예제 #4
0
        private static Camera GetCamera(CameraDto cameraDto)
        {
            // Determine the camera type with reflection:

            Type cameraType = Assembly
                              .GetAssembly(typeof(Camera))
                              .GetTypes()
                              .FirstOrDefault(type => type.Name.ToLower() == (cameraDto.Type + "Camera").ToLower());

            // All the needed code to create 'CameraDslr' or 'CameraMirrorless' if we use AutoMapper:

            // Object cameraObject = Mapper.Map(cameraDto, cameraDto.GetType(), cameraType);

            //  return cameraObject as Camera;

            Camera cameraEntity = new Camera();

            if (cameraType?.Name.ToLower() == "dslrcamera")
            {
                cameraEntity = new DSLRCamera()
                {
                    Make            = cameraDto.Make,
                    Model           = cameraDto.Model,
                    IsFullFrame     = cameraDto.IsFullFrame,
                    MinISO          = cameraDto.MinISO,
                    MaxISO          = cameraDto.MaxISO,
                    MaxShutterSpeed = cameraDto.MaxShutterSpeed
                };
            }
            else if (cameraType?.Name.ToLower() == "mirrorlesscamera")
            {
                cameraEntity = new MirrorlessCamera()
                {
                    Make               = cameraDto.Make,
                    Model              = cameraDto.Model,
                    IsFullFrame        = cameraDto.IsFullFrame,
                    MinISO             = cameraDto.MinISO,
                    MaxISO             = cameraDto.MaxISO,
                    MaxVideoResolution = cameraDto.MaxVideoResolution,
                    MaxFrameRate       = cameraDto.MaxFrameRate
                };
            }

            return(cameraEntity);
        }
        public static Camera ToCamera(this CameraDto cameraDto)
        {
            //var frame = new Matrix44D(
            //    cameraDto.A11, cameraDto.A12, cameraDto.A13, cameraDto.A14,
            //    cameraDto.A21, cameraDto.A22, cameraDto.A23, cameraDto.A24,
            //    cameraDto.A31, cameraDto.A32, cameraDto.A33, cameraDto.A34,
            //    cameraDto.A41, cameraDto.A42, cameraDto.A43, cameraDto.A44);
            var frame = cameraDto.Frame.ToCardanFrame().ToMatrix44D();

            var position  = frame.Offset;
            var direction = frame.Ey;
            var target    = position + direction * cameraDto.TargetDistance;

            var camera = new Camera();

            camera.Frame     = frame;
            camera.Target    = target;
            camera.NearPlane = 1.0;

            return(camera);
        }