/// <summary>Create the morphed images and video.</summary> public void Render(IImageWriter imageWriter, LinePairCollection lines, Bitmap startImageBmp, Bitmap endImageBmp) { _curFrame = 0; double percentagePerFrame = 1.0 / (_options.NumberOfOutputFrames - 1); using (Bitmap clonedStart = Utilities.CreateNewBitmapFrom(startImageBmp)) using (Bitmap clonedEnd = Utilities.CreateNewBitmapFrom(endImageBmp)) { // Write out the starting picture imageWriter.AddFrame(clonedStart); _curFrame = 1; UpdateProgressChanged(); using (FastBitmap startImage = new FastBitmap(startImageBmp)) using (FastBitmap endImage = new FastBitmap(endImageBmp)) { for (int i = 1; i < _options.NumberOfOutputFrames - 1; i++) { _cancellationToken.ThrowIfCancellationRequested(); using (Bitmap frame = RenderFrame(lines, startImage, endImage, percentagePerFrame * i)) { imageWriter.AddFrame(frame); } _curFrame++; UpdateProgressChanged(); } } imageWriter.AddFrame(clonedEnd); _curFrame++; UpdateProgressChanged(); } }
public TagCloudBuilder(IWordsReader reader, IAlgorithm algorithm, IImageWriter writer, IWordsFilter filter) { this.filter = filter; this.reader = reader; this.algorithm = algorithm; this.writer = writer; }
/// <summary>Create the morphed images and video.</summary> public void Render(IImageWriter imageWriter, LinePairCollection lines, Bitmap startImageBmp, Bitmap endImageBmp) { _curFrame = 0; double percentagePerFrame = 1.0 / (_options.NumberOfOutputFrames - 1); using (Bitmap clonedStart = Utilities.CreateNewBitmapFrom(startImageBmp)) using (Bitmap clonedEnd = Utilities.CreateNewBitmapFrom(endImageBmp)) { // Write out the starting picture imageWriter.AddFrame(clonedStart); _curFrame = 1; UpdateProgressChanged(); using (FastBitmap startImage = new FastBitmap(startImageBmp)) using (FastBitmap endImage = new FastBitmap(endImageBmp)) { for (int i = 1; i < _options.NumberOfOutputFrames - 1; i++) { _cancellationToken.ThrowIfCancellationRequested(); using (Bitmap frame = RenderFrame(lines, startImage, endImage, percentagePerFrame * i)) { imageWriter.AddFrame(frame); } _curFrame++; UpdateProgressChanged(); } } imageWriter.AddFrame(clonedEnd); _curFrame++; UpdateProgressChanged(); } }
public ContentWriter(IImageWriter images, IContentPlanExecutor executor, IResponseCaching caching, IOutputWriter writer) { _images = images; _executor = executor; _caching = caching; _writer = writer; }
public ImageConverter(string sourcePath, string convertTo, string outputPath) { _imageReader = ImageReaderFactory.GetInstance().GetImageReader(sourcePath); _imageWriter = ImageWriterFactory.GetInstance() .GetImageWriter((ImageWriteFormat)Enum.Parse(typeof(ImageWriteFormat), convertTo, true), outputPath); }
public void SaveToFile(string path, IImageWriter writer) { using (var fs = new FileStream(path, FileMode.Create)) { writer.SaveToStream(fs, this); } }
public void RegisterImageWriter(ImageFileFormat fileFormat, IImageWriter writerImplementation) { if (_writers.ContainsKey(fileFormat)) throw new ArgumentException("Writer for the image format already registered!", "fileFormat"); _writers.Add(fileFormat, writerImplementation); WritableFileFormats.Add(fileFormat); }
public FreelancerController(IFreelancerService freelancer, IImageWriter imageHandler, IFreelancerHabilityService freelancerHabilityService) { _freelancer = freelancer; _imageHandler = imageHandler; _freelancerHabilityService = freelancerHabilityService; }
public ImagesController(IImageHandler imageHandler, IIndividualsRepository repository, IImageWriter imageWriter) { _imageHandler = imageHandler; _repository = repository; _imageWriter = imageWriter; }
public CustomersController(ILoggerManager logger, IRepositoryWrapper repositories, IImageWriter imageWriter, IOptions <DirectoryConfig> config) { _logger = logger; _repositories = repositories; _imageWriter = imageWriter; _config = config; }
public UserRepository(IOptions <SecurityConfig> config, IImageWriter imageWriter, PolloPolloContext context) { _config = config.Value; _imageWriter = imageWriter; _context = context; _deviceAddress = "AymLnfCdnKSzNHwMFdGnTmGllPdv6Qxgz1fHfbkEcDKo"; _obyteHub = "obyte.org/bb"; }
/// <summary> /// Initializes a new instance of the <see cref="BrandsController" /> class. /// </summary> public BrandsController( IBrandService brandService, ICacheProvider cacheProvider, IImageWriter imageWriter) { this.brandService = brandService; this.cacheProvider = cacheProvider; this.imageWriter = imageWriter; }
public PassthroughImageWriter(IImageWriter writer, params Action <Bitmap> [] handlers) { if (writer == null) { throw new ArgumentNullException("writer"); } _writer = writer; _handlers = handlers; }
public ImageController(IImageRepository imageRepos, IHostingEnvironment hostingEnvironment, IImageWriter imgWriter, UserManager <AppUser> userMgr, IProductRepository productRepos) { imageRepository = imageRepos; _appHostingEnv = hostingEnvironment; imageWriter = imgWriter; userManager = userMgr; productRepository = productRepos; }
public Scene(ICameraProvider cameraProvider, IRayProvider rayProvider, ISceneConfigProvider configProvider, IObjectContainer container, IImageWriter writer, ILightningSourceProvider lightningProvider) { _cameraProvider = cameraProvider; _configProvider = configProvider; _rayProvider = rayProvider; _objContainer = container; _imageWriter = writer; _lightningProvider = lightningProvider; }
public IndividualsController(IIndividualsRepository repository, IMapper mapper, LinkGenerator linkGenerator, IStringLocalizer <IndividualsController> localizer, IImageWriter imageWriter) { this._repository = repository; this._mapper = mapper; this._linkGenerator = linkGenerator; this._localizer = localizer; _imageWriter = imageWriter; }
public FileSystemImageManager(IOptions <ImageManagerOptions> options, ILogger <FileSystemImageManager> logger, IImageReader imageReader, IImageProcessor imageProcessor, IImageWriter imageWriter) { this.options = options.Value; this.logger = logger; reader = imageReader; processor = imageProcessor; writer = imageWriter; }
public ScreenCapturerParameters(string directory, string formatString, Rectangle bounds, IImageWriter writer, bool compress) { _directory = directory; _formatString = formatString; _bounds = bounds; _writer = writer; _compress = compress; if (String.IsNullOrWhiteSpace(_formatString)) { _formatString = ScreenCapturer.DefaultFormatString; } }
public TagsCloudController( IConfiguration configuration, IDataReader reader, IPreprocessor preprocessor, IWordsCounter wordsCounter, ITagsGenerator tagsGenerator, IVisualizer visualizer, IImageWriter imageWriter) { this.configuration = configuration; this.reader = reader; this.preprocessor = preprocessor; this.wordsCounter = wordsCounter; this.tagsGenerator = tagsGenerator; this.visualizer = visualizer; this.imageWriter = imageWriter; }
public AccountController( UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager, IConfiguration configuration, IAuthService authService, IAccountService accountService, IImageWriter imageHandler ) { _userManager = userManager; _signInManager = signInManager; this._configuration = configuration; _authService = authService; _dateTime = DateTime.Now; _accountService = accountService; _imageHandler = imageHandler; }
public static void InitiateConversion(string originalPath, string destinationPath, string outputFormat) { string originalTypeStr = GetExtension(originalPath); ImageType originalType; ImageType finalType; try { originalType = (ImageType)Enum.Parse(typeof(ImageType), originalTypeStr, true); finalType = (ImageType)Enum.Parse(typeof(ImageType), outputFormat, true); } catch (Exception) { throw new InvalidOperationException("Unsupported Image Type"); } IFactory <IImageReader> readerFactory = new ReaderFactory(); IFactory <IImageWriter> writerFactory = new WriterFactory(); IImageReader reader = readerFactory.Create(originalType); IImageWriter writer = writerFactory.Create(finalType); var image = reader.Read(originalPath); Converter converter = new Converter(writer); converter.Convert(image, destinationPath); Bitmap pic = new Bitmap(image.Header.Width, image.Header.Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb); for (int i = 0; i < image.Header.Height; i++) { for (int j = 0; j < image.Header.Width; j++) { Color c = Color.FromArgb(image.Bitmap[i, j].R, image.Bitmap[i, j].G, image.Bitmap[i, j].B); pic.SetPixel(j, i, c); } } pic.Save("testcow.bmp"); string GetExtension(string path) { return(path.Substring(path.LastIndexOf('.') + 1)); } }
public AssignmentController(UserManager <ApplicationUser> userManager, IConfiguration configuration, IAssignmentRepository assignmentRepository, IExhibitorRepository exhibitorRepository, IGroupRepository groupRepository, ICategoryRepository categoryRepository, IImageWriter imageWriter, IQuestionRepository questionRepository) { _groupRepository = groupRepository; _userManager = userManager; _configuration = configuration; _assignmentRepository = assignmentRepository; _exhibitorRepository = exhibitorRepository; _categoryRepository = categoryRepository; _exhibitorManager = new ExhibitorManager(exhibitorRepository, categoryRepository, questionRepository); _questionRepository = questionRepository; _imageWriter = imageWriter; }
public DocumentImageController(IImageWriter imageWriter) { _imageWriter = imageWriter; }
public ScreenCapturerParameters(string directory, string formatString, Rectangle bounds, IImageWriter writer) : this(directory, formatString, bounds, writer, false) { }
public PersonController(IImageWriter imageWriter) { _imageWriter = imageWriter; }
public static async Task Main(string[] args) { Stopwatch st = new Stopwatch(); st.Start(); IMutableImageFactory <MutableByteImage> factory = null; List <IFilter <MutableByteImage> > filters = null; IImageReader <MutableByteImage> inputMode = null; IImageWriter <MutableByteImage> outputMode = null; ILogger logger = null; IImageProcessingStrategy <MutableByteImage> processingStrategy = null; bool throwMe = false; void setupCommons(CommonOptions info) { logger = CreateLogger(info); bool throwMeHere = false; (filters, throwMeHere) = ParseFilterParameters(info.Filters); throwMe |= throwMeHere; factory = new MutableByteImageFactory(logger); logger?.WriteLine(info.ToString().Replace(",", Environment.NewLine), Verbosity.Info); (inputMode, throwMeHere) = SetInput(info, factory, logger); throwMe |= throwMeHere; (outputMode, throwMeHere) = SetOutput(info, logger, factory); throwMe |= throwMeHere; } var result = Parser.Default .ParseArguments <InfoOptions, StackAllOptions, StackProgressiveOptions, StackContinuousOptions, TestOptions>(args) .WithParsed <InfoOptions>(info => { GetInfo(info); return; }) .WithParsed <StackAllOptions>(info => { setupCommons(info); // todo switch between stackall and stackallmerge, if supported by filter // processingStrategy = new StackAllStrategy(); // might be unsafe processingStrategy = new StackAllMergeStrategy <MutableByteImage>(logger, factory); }) .WithParsed <StackProgressiveOptions>(info => { setupCommons(info); processingStrategy = new StackProgressiveStrategy <MutableByteImage>(logger, factory); }) .WithParsed <StackContinuousOptions>(info => { setupCommons(info); if (info.Count == 0) { logger?.WriteLine("You have to define --stackCount for continuous stacking", Verbosity.Error); throwMe = true; } processingStrategy = new StackContinousStrategy <MutableByteImage>(info.Count, logger, factory); }) .WithParsed <TestOptions>(info => { info.UseOutputPipe = false; info.OutputFile = "."; info.OutputFolder = "."; logger = new Logger(Console.Out); factory = new MutableByteImageFactory(logger); inputMode = new TestImageReader <MutableByteImage> (info.Count, info.Width, info.Height, PixelFormat.Format24bppRgb, logger, factory); outputMode = new TestImageWriter <MutableByteImage>(logger, factory); processingStrategy = new StackAllMergeStrategy <MutableByteImage>(logger, factory); RunBenchmark(info, logger, new MutableByteImageFactory(logger)).Wait(); Process.GetCurrentProcess().Close(); }) .WithNotParsed(x => logger?.WriteLine(String.Join(Environment.NewLine, x.Select(y => y.ToString()).ToArray()), Verbosity.Error)); if (throwMe) { logger?.WriteLine("Invalid Configuration, see issues above.", Verbosity.Error); return; } if (inputMode == null || outputMode == null) { logger?.WriteLine($"Input: {inputMode}, Output:{outputMode}", Verbosity.Error); logger?.WriteLine("IO undefined", Verbosity.Error); return; } if (processingStrategy == null) { logger?.WriteLine("Not processing strategy defined", Verbosity.Error); } logger?.WriteLine($"{inputMode} {outputMode} {processingStrategy}", Verbosity.Info); await processingStrategy.Process(inputMode, filters, outputMode); st.Stop(); logger?.WriteLine($"Processing took {st.ElapsedMilliseconds / 1000d}", Verbosity.Info); logger?.Dispose(); }
public ImagesController(SommerhusContext context, IImageWriter imageWriter) { _context = context; _imageWriter = imageWriter; }
public UploadRoomTypeImageCommandHandler(IHotelDbContext context, IImageWriter imageWriter) { this.context = context; this.imageWriter = imageWriter; }
public ImageHandler() { _imageWriter = new ImageWriter.Classes.ImageWriter(); }
public void SaveToStream(Stream stream, IImageWriter writer) { writer.SaveToStream(stream, this); }
public Converter(IImageReader imageReader, IImageWriter imageWriter) { ImageReader = imageReader; ImageWriter = imageWriter; }
public ProductRepository(IImageWriter imageWriter, IEmailClient emailClient, PolloPolloContext context) { _imageWriter = imageWriter; _emailClient = emailClient; _context = context; }
public ImageFileService(IImageWriter imageWriter) { _imageWriter = imageWriter; }
public ArticleController(IImageWriter imageWriter) { _imageWriter = imageWriter; }
public ApartmentImageController(IImageWriter imageWriter, IExistsImahesOperator imahesOperator) { _imageWriter = imageWriter; _imahesOperator = imahesOperator; }
public ImageHandler(IImageWriter imageWriter) { _imageWriter = imageWriter; }
public PassthroughImageWriter(IImageWriter writer, params Action<Bitmap> [] handlers) { if (writer == null) throw new ArgumentNullException("writer"); _writer = writer; _handlers = handlers; }