/// <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;
}