c# free pdf viewer component : Add a page to a pdf document control Library platform web page .net asp.net web browser ReadingAndWritingImageFiles3-part839

For example, assume that we want to read an OpenEXR image from a C stdio file (of type 
FILE *
) that has 
already been opened.  To do this, we derive a new class, 
C_IStream
, from 
IStream
 The declaration of 
class 
IStream
looks like this:
class IStream
{
public:
virtual ~IStream ();
virtual bool    read (char c[], int n) = 0;
virtual Int64   tellg () = 0;
virtual void    seekg (Int64 pos) = 0;
virtual void    clear ();
const char *    fileName () const;
virtual bool    isMemoryMapped () const;
virtual char *  readMemoryMapped (int n);
protected:
IStream (const char fileName[]);
private:
...
};
Our derived class needs a public constructor, and it must override four methods: 
class C_IStream: public IStream
{
public:
C_IStream (FILE *file, const char fileName[]):
IStream (fileName), _file (file) {}
virtual bool    read (char c[], int n);
virtual Int64   tellg ();
virtual void    seekg (Int64 pos);
virtual void    clear ();
private:
FILE *          _file;
};
read(c,n)
reads 
n
bytes from the file, and stores them in array 
c
.  If reading hits the end of the file before 
bytes have been read, or if an I/O error occurs, 
read(c,n)
throws an exception.  If 
read(c,n)
hits the end 
of the file after reading 
n
bytes, it returns 
false
, otherwise it returns 
true
:
bool
C_IStream::read (char c[], int n)
{
if (n != fread (c, 1, n, _file))
{
// fread() failed, but the return value does not distinguish
// between I/O errors and end of file, so we call ferror() to
// determine what happened.
if (ferror (_file))
Iex::throwErrnoExc();
else
throw Iex::InputExc ("Unexpected end of file.");
}
31
Add a page to a pdf document - insert pages into PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide C# Users to Insert (Empty) PDF Page or Pages from a Supported File Format
add and delete pages in pdf; add pages to pdf in preview
Add a page to a pdf document - VB.NET PDF Page Insert Library: insert pages into PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Easy to Use VB.NET APIs to Add a New Blank Page to PDF Document
add page numbers to a pdf document; add page number to pdf print
return feof (_file);
}
tellg()
returns the current reading position, in bytes, from the beginning of the file.  The next 
read()
call 
will begin reading at the indicated position:
Int64
C_IStream::tellg ()
{
return ftell (_file);
}
seekg(pos)
sets the current reading position to 
pos
bytes from the beginning of the file:
void
C_IStream::seekg (Int64 pos)
{
clearerr (_file);
fseek (_file, pos, SEEK_SET);
}
clear()
clears any error flags that may be set on the file after a 
read()
or 
seekg()
operation has failed:
void
C_IStream::clear ()
{
clearerr (_file);
}
In order to read an RGBA image from an open C stdio file, we first make a 
C_IStream
object.  Then we 
create an 
RgbaInputFile
, passing the 
C_IStream
instead of a file name to the constructor.  After that, we 
read the image as usual (see Reading an RGBA Image File, on page 7):
void
readRgbaFILE (FILE *cfile,
const char fileName[],
Array2D<Rgba> &pixels,
int &width,
int &height)
{
C_IStream istr (cfile, fileName);
RgbaInputFile file (istr);
Box2i dw = file.dataWindow();
width  = dw.max.x - dw.min.x + 1;
height = dw.max.y - dw.min.y + 1;
pixels.resizeErase (height, width);
file.setFrameBuffer (&pixels[0][0] - dw.min.x - dw.min.y * width, 1, width);
file.readPixels (dw.min.y, dw.max.y);
}
Memory-Mapped I/O
When the IlmImf library reads an image file, pixel data are copied several times on their way from the file to 
the application's frame buffer.  For compressed files, the time spent copying is usually not significant when 
compared to how long it takes to uncompress the data.  However, when uncompressed image files are being 
read from a fast file system, it may be advantageous to eliminate one or two copy operations by using 
memory-mapped I/O.
Memory-mapping establishes a relationship between a file and a program's virtual address space, such that 
from the program's point of view the file looks like an array of type 
char
.  The contents of the array match 
the data in the file.  This allows the program to access the data in the file directly, bypassing any copy 
operations associated with reading the file via a C++ 
std::ifstream
or a C 
FILE *
.
32
VB.NET PDF insert image library: insert images into PDF in vb.net
VB.NET PDF - Add Image to PDF Page in VB.NET. Guide VB.NET Programmers How to Add Images in PDF Document Using XDoc.PDF SDK for VB.NET.
add page numbers pdf; add page numbers to pdf using preview
C# PDF insert image Library: insert images into PDF in C#.net, ASP
How to insert and add image, picture, digital photo, scanned signature or logo into PDF document page in C#.NET class application?
add page number to pdf hyperlink; adding a page to a pdf document
Classes derived from 
IStream
can optionally support memory-mapped input.  In order to do this, a derived 
class must override two virtual functions, 
isMemoryMapped()
and 
readMemoryMapped()
, in addition to 
the functions needed for regular, non-memory-mapped input:
class MemoryMappedIStream: public IStream
{
public:
MemoryMappedIStream (const char fileName[]);
virtual ~MemoryMappedIStream ();
virtual bool    isMemoryMapped () const;
virtual char *  readMemoryMapped (int n);
virtual bool    read (char c[], int n);
virtual Int64   tellg ();
virtual void    seekg (Int64 pos);
private:
char *          _buffer;
Int64           _fileLength;
Int64           _readPosition;
};
The constructor for class 
MemoryMappedIStream
maps the contents of the input file into the program's 
address space.  Memory mapping is not portable across operating systems.  The example shown here uses the 
POSIX 
mmap()
system call.  On Windows files can be memory-mapped by calling 
CreateFileMapping() 
and 
MapViewOfFile()
:
MemoryMappedIStream::MemoryMappedIStream (const char fileName[]):
IStream (fileName),
_buffer (0),
_fileLength (0),
_readPosition (0)
{
int file = open (fileName, O_RDONLY);
if (file < 0)
THROW_ERRNO ("Cannot open file \"" << fileName << "\".");
struct stat stat;
fstat (file, &stat);
_fileLength = stat.st_size;
_buffer = (char *) mmap (0, _fileLength, PROT_READ, MAP_PRIVATE, file, 0);
close (file);
if (_buffer == MAP_FAILED)
THROW_ERRNO ("Cannot memory-map file \"" << fileName << "\".");
}
The destructor frees the address range associated with the file by un-mapping the file.  The POSIX version 
shown here uses 
munmap()
.  A Windows version would call 
UnmapViewOfFile()
and 
CloseHandle()
:
MemoryMappedIStream::~MemoryMappedIStream ()
{
munmap (_buffer, _fileLength);
}
33
C# PDF Password Library: add, remove, edit PDF file password in C#
your PDF document in C# project, XDoc.PDF provides some PDF security settings. On this page, we will talk about how to achieve this via Add necessary references
add pages to an existing pdf; adding a page to a pdf in reader
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
This .NET PDF Document Add-On integrates mature PDF document page processing functions, including extracting one or more page(s) from PDF document.
adding page to pdf; add page to pdf preview
Function 
isMemoryMapped()
returns 
true
to indicate that memory-mapped input is supported.  This 
allows the IlmImf library to call 
readMemoryMapped()
instead of 
read()
:
bool
MemoryMappedIStream::isMemoryMapped () const
{
return true;
}
readMemoryMapped()
is analogous to 
read()
, but instead of copying data into a buffer supplied by the 
caller, 
readMemoryMapped()
returns a pointer into the memory-mapped file, thus avoiding the copy 
operation:
char *
MemoryMappedIStream::readMemoryMapped (int n)
{
if (_readPosition >= _fileLength)
throw Iex::InputExc ("Unexpected end of file.");
if (_readPosition + n > _fileLength)
throw Iex::InputExc ("Reading past end of file.");
char *data = _buffer + _readPosition;
_readPosition += n;
return data;
}
The 
MemoryMappedIStream
class must also implement the regular 
read()
function, as well as 
tellg() 
and 
seekg()
:
bool
MemoryMappedIStream::read (char c[], int n)
{
if (_readPosition >= _fileLength)
throw Iex::InputExc ("Unexpected end of file.");
if (_readPosition + n > _fileLength)
throw Iex::InputExc ("Reading past end of file.");
memcpy (c, _buffer + _readPosition, n);
_readPosition += n;
return _readPosition < _fileLength;
}
Int64
MemoryMappedIStream::tellg ()
{
return _readPosition;
}
void
MemoryMappedIStream::seekg (Int64 pos)
{
_readPosition = pos;
}
Class 
MemoryMappedIStream
does not need a 
clear()
function.  Since the memory-mapped file has no 
error flags that need to be cleared, the 
clear()
method provided by class 
IStream
, which does nothing, can 
be re-used.
Memory-mapping a file can be faster than reading the file via a C++ 
std::istream
or a C 
FILE *
, but the 
extra speed comes at a cost.  A large memory-mapped file can occupy a significant portion of a program's 
virtual address space.  In addition, mapping and un-mapping many files of varying sizes can severely 
fragment the address space.  After a while, the program may be unable to map any new files because there is 
no contiguous range of free addresses that would be large enough hold a file, even though the total amount of 
34
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via password by using simple VB.NET demo code. Open password protected PDF. Add password to PDF.
add pages to pdf document; add page to pdf without acrobat
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Insert Image to PDF. Image: Remove Image from PDF Page. Image: Copy, Paste, Cut Image in Page. Link: Edit Images. Redact Pages. Annotation & Drawing. Add Sticky
add page numbers to pdf; add a page to a pdf document
free space would be sufficient.  An application program that uses memory-mapped I/O should manage its 
virtual address space in order to avoid fragmentation.  For example, the program can reserve several address 
ranges, each one large enough to hold the largest file that the program expects to read.  The program can then 
explicitly map each new file into one of the reserved ranges, keeping track of which ranges are currently in 
use.
Miscellaneous
Is this an OpenEXR File?
Sometimes we want to test quickly if a given file is an OpenEXR file.  This can be done by looking at the 
beginning of the file:  The first four bytes of every OpenEXR file contain the 32-bit integer "magic number" 
20000630 in little-endian byte order.  After reading a file's first four bytes via any of the operating system's 
standard file I/O mechanisms, we can compare them with the magic number by explicitly testing if the bytes 
contain the values 
0x76
0x2f
0x31
, and 
0x01
.
Given a file name, the following function returns 
true
if the corresponding file exists, is readable, and 
contains an OpenEXR image:
bool
isThisAnOpenExrFile (const char fileName[])
{
std::ifstream f (fileName, std::ios_base::binary);
char b[4];
f.read (b, sizeof (b));
return !!f && b[0] == 0x76 && b[1] == 0x2f && b[2] == 0x31 && b[3] == 0x01;
}
Using this function does not require linking with the IlmImf library.
Programs that are linked with the IlmImf library can determine if a given file is an OpenEXR file by calling 
one of the following functions, which are part of the library:
bool isOpenExrFile (const char fileName[], bool &isTiled);
bool isOpenExrFile (const char fileName[]);
bool isTiledOpenExrFile (const char fileName[]);
bool isOpenExrFile (IStream &is, bool &isTiled);
bool isOpenExrFile (IStream &is);
bool isTiledOpenExrFile (IStream &is);
Is this File Complete?
Sometimes we want to test if an OpenEXR file is complete.  The file may be missing pixels, either because 
writing the file is still in progress or because writing was aborted before the last scan line or tile was stored in 
the file.  Of course, we could test if  a given file is complete by attempting to read the entire file, but the input 
file classes in the IlmImf library have an 
isComplete()
method that is faster and more convenient.
The following function returns 
true
or 
false
, depending on whether a given OpenEXR file is complete or 
not:
bool
isComplete (const char fileName[])
{
InputFile in (fileName);
return in.isComplete();
}
35
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
DLLs for Deleting Page from PDF Document in VB.NET Class. In order to run the sample code, the following steps would be necessary. Add necessary references:
add and remove pages from a pdf; add page numbers pdf files
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
pageIndexes.Add(3); // The 4th page. String outputFilePath = Program.RootPath + "\\" Output.pdf"; newDoc.Save(outputFilePath);
adding page numbers pdf; add page numbers to a pdf file
Preview Images
Graphical user interfaces for selecting image files often represent files as small preview or thumbnail images. 
In order to make loading and displaying the preview images fast, OpenEXR files support storing preview 
images in the file headers.
A preview image is an attribute whose value is of type 
PreviewImage
.  A 
PreviewImage
object is an array 
of pixels of type 
PreviewRgba
 A pixel has four components, 
r
g
b
and 
a
, of type 
unsigned char
where 
r
g
and 
b
are the pixel's red, green and blue components, encoded with a gamma of 2.2.  
a
is the 
pixel's alpha channel; 
r
and 
b
should be premultiplied by 
a
 On a typical display with 8-bits per 
component, the preview image can be shown by simply loading the 
r
and 
b
components into the display's 
frame buffer.  (No gamma correction or tone mapping is required.)
The code fragment below shows how to test if an OpenEXR file has a preview image, and how to access a 
preview image's pixels:
RgbaInputFile file (fileName);
if (file.header().hasPreviewImage())
{
const PreviewImage &preview = file.header().previewImage();
for (int y = 0; y < preview.height(); ++y)
for (int x = 0; x < preview.width(); ++x)
{
const PreviewRgba &pixel = preview.pixel (x, y);
... 
}
}
Writing an OpenEXR file with a preview image is shown in the following example.  Since the preview image 
is an attribute in the file's header, it is entirely separate from the main image.  Here the preview image is a 
smaller version of the main image, but this is not required; in some cases storing an easily recognizable icon 
may be more appropriate.  This example uses the RGBA-only interface to write a scan line based file, but 
preview images are also supported for files that are written using the general interface, and for tiled files.
void
writeRgbaWithPreview1 (const char fileName[],
const Array2D<Rgba> &pixels,
int width,
int height)
{
Array2D <PreviewRgba> previewPixels;                                        // 1
int previewWidth;                                                           // 2
int previewHeight;                                                          // 3
makePreviewImage (pixels, width, height,                                    // 4
previewPixels, previewWidth, previewHeight);
Header header (width, height);                                              // 5
header.setPreviewImage                                                      // 6
(PreviewImage (previewWidth, previewHeight, &previewPixels[0][0]));
RgbaOutputFile file (fileName, header, WRITE_RGBA);                         // 7
file.setFrameBuffer (&pixels[0][0], 1, width);                              // 8
file.writePixels (height);                                                  // 9
}
Lines 1 through 4 generate the preview image.  Line 5 creates a header for the image file.  Line 6 converts the 
preview image into a 
PreviewImage
attribute, and adds the attribute to the header.  Lines 7 through 9 store 
the header (with the preview image) and the main image in a file.
36
Function 
makePreviewImage()
, called in line 4, generates the preview image by scaling the main image 
down to one eighth of its original width and height:
void
makePreviewImage (const Array2D<Rgba> &pixels,
int width,
int height,
Array2D<PreviewRgba> &previewPixels,
int &previewWidth,
int &previewHeight)
{
const int N = 8;
previewWidth  = width / N;
previewHeight = height / N;
previewPixels.resizeErase (previewHeight, previewWidth);
for (int y = 0; y < previewHeight; ++y)
{
for (int x = 0; x < previewWidth; ++x)
{
const Rgba  &inPixel = pixels[y * N][x * N];
PreviewRgba &outPixel = previewPixels[y][x];
outPixel.r = gamma (inPixel.r);
outPixel.g = gamma (inPixel.g);
outPixel.b = gamma (inPixel.b);
outPixel.a = int (clamp (inPixel.a * 255.f, 0.f, 255.f) + 0.5f);
}
}
}
To make this example easier to read, scaling the image is done by just sampling every eighth pixel of every 
eighth scan line.  This can lead to aliasing artifacts in the preview image; for a higher-quality preview image, 
the main image should be lowpass-filtered before it is subsampled.
Function 
makePreviewImage()
calls  
gamma()
to convert the floating-point red, green, and blue 
components of the sampled main image pixels to 
unsigned char
values. 
gamma()
is a simplified version 
of what the exrdisplay program does in order to show an OpenEXR image's floating-point pixels on the 
screen (for details, see exrdisplay's source code):
unsigned char
gamma (float x)
{
x = pow (5.5555f * max (0.f, x), 0.4545f) * 84.66f;
return (unsigned char) clamp (x, 0.f, 255.f);
}
makePreviewImage()
converts the pixels' alpha component to unsigned char by by linearly mapping the 
range [0.0, 1.0] to [0, 255].
Some programs write image files one scan line or tile at a time, while the image is being generated.  Since the 
image does not yet exist when the file is opened for writing, it is not possible to store a preview image in the 
file's header at this time (unless the preview image is an icon that has nothing to do with the main image). 
However, it is possible to store a blank preview image in the header when the file is opened.  The preview 
image can then be updated as the pixels become available.  This is demonstrated in the following example:
void
writeRgbaWithPreview2 (const char fileName[],
int width,
int height)
{
Array <Rgba> pixels (width);
const int N = 8;                                         
37
int previewWidth = width / N;
int previewHeight = height / N;
Array2D <PreviewRgba> previewPixels (previewHeight, previewWidth);
Header header (width, height);
header.setPreviewImage (PreviewImage (previewWidth, previewHeight));
RgbaOutputFile file (fileName, header, WRITE_RGBA);
file.setFrameBuffer (pixels, 1, 0);
for (int y = 0; y < height; ++y)
{
generatePixels (pixels, width, height, y);
file.writePixels (1);
if (y % N == 0)
{
for (int x = 0; x < width; x += N)
{
const Rgba  &inPixel = pixels[x];
PreviewRgba &outPixel = previewPixels[y / N][x / N];
outPixel.r = gamma (inPixel.r);
outPixel.g = gamma (inPixel.g);
outPixel.b = gamma (inPixel.b);
outPixel.a = int (clamp (inPixel.a * 255.f, 0.f, 255.f) + 0.5f);
}
}
}
file.updatePreviewImage (&previewPixels[0][0]);
}
Environment Maps
An environment map is an image that represents an omnidirectional view of a three-dimensional scene as 
seen from a particular 3D location.  Every pixel in the image corresponds to a 3D direction, and the data 
stored in the pixel represent the amount of light arriving from this direction.  In 3D rendering applications, 
environment maps are often used for image-based lighting techniques that appoximate how objects are 
illuminated by their surroundings.  Environment maps with enough dynamic range to represent even the 
brightest light sources in the environment are sometimes called "light probe images."
In an OpenEXR file, an environment map is stored as a rectangular pixel array, just like any other image, but 
an attribute in the file header indicates that the image is an environment map.  The attribute's value, which is 
of type 
Envmap
, specifies the relation between 2D pixel locations and 3D directions.  
Envmap
is an 
enumeration type.  Two values are possible:
ENVMAP_LATLONG
Latitude-Longitude Map.  The environment is projected onto the image using polar 
coordinates (latitude and longitude).  A pixel's x coordinate corresponds to its 
longitude, and the y coordinate corresponds to its latitude.  The pixel in the upper left 
corner of the data window has latitude +π/2 and longitude +π; the pixel in the lower 
right corner has latitude -π/2 and longitude -π .
In 3D space, latitudes -π/2 and +π/2 correspond to the negative and positive y 
direction.  Latitude 0, longitude 0 points in the positive z direction; latitude 0, 
longitude π/2 points in the positive x direction.
38
For a latitude-longitude map, the size of the data window should be 2×N by N pixels 
(width by height), where N can be any integer greater than 0.
ENVMAP_CUBE
Cube Map.  The environment is projected onto the six faces of an axis-aligned cube. 
The cube's faces are then arranged in a 2D image as shown below.
For a cube map, the size of the data window should be N by 6×N pixels (width by 
height), where N can be any integer greater than 0.
Note:  Both kinds of environment maps contain redundant pixels:  In a latitude-longitude map, the top row 
and the bottom row of pixels correspond to the map's north pole and south pole (latitudes  +π/2  and  -π/2).  In 
each of those two rows all pixels are the same.  The leftmost column and the rightmost column of pixels both 
correspond to the meridian with longitude +π (or, equivalently, -π).  The pixels in the leftmost column are 
repeated in the rightmost column.  In a cube-face map, the pixels along each edge of a face are repeated along 
the corresponding edge of the adjacent face.  The pixel in each corner of a face is repeated in the 
corresponding corners of the two adjacent faces.
39
The following code fragment tests if an OpenEXR file contains an environment map, and if it does, which 
kind:
RgbaInputFile file (fileName);
if (hasEnvmap (file.header()))
{
Envmap type = envmap (file.header());
...
}
For each kind of environment map, the IlmImf library provides a set of routines that convert from 3D 
directions to 2D floating-point pixel locations and back.  Those routines are useful in application programs 
that create environment maps and in programs that perform map lookups.  For details, see the header file 
ImfEnvmap.h
.
40
Documents you may be interested
Documents you may be interested