text:
int main(int argc, char ** argv)
{
	////////////////////////
	// 1°/ Window creation:
	//			- Create OpenGL Window
	//
	// => <OpenGLEngine\windowInterface.hpp>
	////////////////////////
	size_t WINDOW_WIDTH = OpenGLEngine::window::WINDOW_WIDTH; // default width
	size_t WINDOW_HEIGHT = OpenGLEngine::window::WINDOW_HEIGHT; // default height
	OpenGLEngine::window::Window window(WINDOW_WIDTH, WINDOW_HEIGHT, "My OpenGL Engine");

	////////////////////////
	// 2°/ Default Initialization Setup:
	//			- GLEW/GL specifications
	////////////////////////
	// Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions
	glewExperimental = GL_TRUE;
	// Initialize GLEW to setup the OpenGL Function pointers
	glewInit();
	// Define the viewport dimensions
	glViewport(0, 0, window.getWidth(), window.getHeight());

	// Setup OpenGL options
	// Depth-Testing
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LESS);
	// Stencil-Buffer
	//glEnable(GL_STENCIL_TEST);
	//glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
	//glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

	// face culling
	//glEnable(GL_CULL_FACE); // enable face culling
	glCullFace(GL_BACK); //GL_BACK: Culls only the back faces.
	glFrontFace(GL_CCW);

	// GL Clear Color specification
	glClearColor(1.0f, 1.0f, 1.0f, 1.0f);

	////////////////////////
	// 2°/ Camera creation:
	//			- Create a Camera
	// The camera is located at a given position in world space and is looking at a given point (in world space)
	// From specified FOV and aspect ratio, we build View (World to Camera space) Matrix and Projection (persepective divide) Matrix
	//
	// => <OpenGLEngine\cameraInterface.hpp>
	/////////////////////////
	glm::vec3 cameraPosition = glm::vec3(0.0f, 0.0f, 3.0f);
	glm::vec3 cameraFocus = glm::vec3(0.0f);
	float fov = 70.0;
	OpenGLEngine::camera::Camera camera(window.aspectRatio(), cameraPosition, cameraFocus, fov);

	////////////////////////
	// 3°/ Shader and Uniform loading
	//
	// The engine offers custom OpenGL wrapper classes for Shaders & Uniforms (Textures included) as well as Meshes
	// Memory managment is left to the user.
	// One way to do it is to use custom memory pools for each objects:
	//	std::vector<OpenGLEngine::Shader> or std::unordered_map<std::string, OpenGLEngine::Shader> shaderPool ...
	// NB: dealocation for each object is done when destructor is called.
	//
	// => Shaders <OpenGLEngine\shaderInterface.hpp>
	// => Uniforms <OpenGLEngine\uniformInterface.hpp>
	// => Textures <OpenGLEngine\textureInterface.hpp>
	////////////////////////

	/////////////////////////////
	// SHADERS
	// NB: No support for tesselation nor geometry shaders in current build
	/////////////////////////////
	OpenGLEngine::Shader pbrShader("pbr.vert", "pbr.frag");
	OpenGLEngine::Shader shadowMappingShader("shadowMapping.vert", "shadowMapping.frag");

	/////////////////////////////
	// UNIFORMS
	/////////////////////////////
	OpenGLEngine::f3vUniform vLight;
	vLight.name = "lightPos";
	vLight.value = glm::vec3(8 * 2, 7 * 2, -3 * 2);
	vLight.type = "f3v";

	/////////////////////////////
	// TEXTURES
	/////////////////////////////
	GLuint wallTexture = OpenGLEngine::textureClient::loadTexture("Resources/Textures/crakedpaint.jpg");
	OpenGLEngine::Texture2D tex_wall;
	tex_wall.ID = wallTexture;
	tex_wall.name = "wallTexture";
	tex_wall.type = "sampler2D";

	////////////////////////
	// 3°/ Gemometry Setup
	//
	// The engine offers custom OpenGL wrapper classes for 3D Meshes.
	//		- A mesh is made of a Geometry (i.e: OpenGL VAO & VBO) and  a Material (associated Shader and Uniform & Textures).
	//		- A mesh is not nesisarilly rendered using Material specified at creation, but Shader,Uniform&Texture binding & linking is left to the user
	//		  (for such a case, be sure to only render the mesh gemometry)...
	//		- A mesh has a specified position in world space (=> Model to World Matrix)
	//
	// Memory managment is left to the user.
	// One way to do it is to use custom memory pools for each objects:
	//		std::unordered_map<std::string, OpenGLEngine::Geometry> geometryPool
	//		std::unordered_map<std::string, OpenGLEngine::Material> materialPool
	//		std::unordered_map<std::string, OpenGLEngine::Mesh> meshPool
	// NB: dealocation for each object is done when destructor is called.
	//
	// => <OpenGLEngine\mesh.hpp> (mesh)
	//		- #include <OpenGLEngine\modelGeometry.hpp>
	//		- #include <OpenGLEngine\modelMaterial.hpp>
	////////////////////////

	/////////////////////////////
	// GEOMETRY
	/////////////////////////////
	float y_translate = -2.0;
	glm::vec3 meshPos = glm::vec3(0.0, -3.0 + y_translate, 0.0);
	OpenGLEngine::Geometry mesh_geometry("Resources/Models/clumsy-dragon.obj", meshPos, 5.0);

	OpenGLEngine::Geometry mesh2_geometry("Resources/Models/stanford-dragon.obj", meshPos, 1.0);
	mesh2_geometry.setWorldSpacePosition(glm::vec3(-5.5, -2.0 + y_translate, 0.0));

	OpenGLEngine::Geometry mesh3_geometry("Resources/Models/dragon-xyz-rgb-scan.obj", meshPos, 1.0);
	mesh3_geometry.setWorldSpacePosition(glm::vec3(0.5, -2.0 + y_translate, -8));

	OpenGLEngine::Geometry plane_geometry("PlaneGeometry", 40, glm::vec3(0.0, -2.0 + y_translate, 0.0));

	/////////////////////////////
	// MATERIAL
	/////////////////////////////
	std::vector<OpenGLEngine::Uniform *> uniformVec = { &vLight };
	OpenGLEngine::Material geometryPassMaterial(&std::vector<OpenGLEngine::Texture *>(), &uniformVec, &pbrShader);

	std::vector<OpenGLEngine::Texture *> shadowlMap_tex = { &tex_wall };
	OpenGLEngine::Material normalMap_material(&shadowlMap_tex, &std::vector<OpenGLEngine::Uniform *>(), &shadowMappingShader);

	/////////////////////////////
	// MESH
	/////////////////////////////
	OpenGLEngine::Mesh clumbsy_dragon(&mesh_geometry, &geometryPassMaterial);
	OpenGLEngine::Mesh standford_dragon_bunny(&mesh2_geometry, &geometryPassMaterial);
	OpenGLEngine::Mesh xyz_dragon(&mesh3_geometry, &geometryPassMaterial);

	OpenGLEngine::Mesh plane(&plane_geometry, &normalMap_material);

	////////////////////////
	// 4°/ Scene Setup
	//
	// A scene is just a wrapper to render more effecitenly all the mesh present in the mesh
	//	(ie Matrix linking, controler managment and uniform binding & linking)
	//
	// Memory managment is left to the user. No copies are done
	//
	// => <OpenGLEngine\scene.hpp>
	////////////////////////
	OpenGLEngine::Scene scene;
	scene.addMesh(&clumbsy_dragon);
	scene.addMesh(&standford_dragon_bunny);
	scene.addMesh(&xyz_dragon);
	scene.addMesh(&plane);

	////////////////////////
	// 4°/ FBO Setup
	//
	// For multiple pass rendering, the engine offers FBO, RBO wrappers
	//
	// => <OpenGLEngine\frameBuffer.hpp>
	//    <OpenGLEngine\renderBuffer.hpp>
	////////////////////////
	OpenGLEngine::Geometry screenQuadGeometry("ScreenGeometry", 1.0, glm::vec3(0.0, 0.0, 0.0));

	////////////////////////////////////////////////////////////////////////////////////////////////
	////////////////////////
	// Depth Map rendering
	// "Variance Shadow Maps // William Donnelly, Andrew Lauritzen"
	// "GPU Gems 3 - Chapter 8. Summed-Area Variance Shadow Maps // Andrew Lauritzen"
	// cf: http://www.punkuser.net/vsm/vsm_paper.pdf
	//	   http://http.developer.nvidia.com/GPUGems3/gpugems3_ch08.html
	////////////////////////
	// We render depth map from point of view of the light:
	//	=> r: depth
	//	   g: depth*depth + bias
	// NB: f(x,y) = depth + x*df/dx + y*df/dy
	// M2 = E(f²) = E(depth²) + E(x²)*(df/dx)² + E(y²)*(df/dy)² // E(x) = E(y) = E(xy) = 0
	//		E(depth²) = depth²
	//		E(x²) = sd_pixel² = (1/2)² = 1/4, pixel being a symetrical Gaussian distribution
	// bias = 0.25 * ((df/dx)² + (df/dy)²)
	//
	// Once the variancce shadow map is rendered, we can enable classical texture filtering
	// We perform a Bi-Lateral blur to average out the shadows
	OpenGLEngine::Shader shadowMapShader("depthShader.vert", "depthShader.frag");
	OpenGLEngine::Shader bilateralBlurShader("bilateralBlurShader.vert", "bilateralBlurShader.frag");

	////////////////////////
	// Initilalize Depth Map
	////////////////////////
	size_t ShadowMap_width = window.getWidth();
	size_t ShadowMap_height = window.getHeight();
	GLuint ShadowMap_textureID;
	glGenTextures(1, &ShadowMap_textureID);
	glBindTexture(GL_TEXTURE_2D, ShadowMap_textureID);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

	GLfloat borderColor[] = { 1.0, 1.0, 1.0, 1.0 };
	glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
	glBindTexture(GL_TEXTURE_2D, 0);

	////////////////////////
	// two render pass:
	//		1° light depth map:
	//			=> r: depth
	//			   g: depth²
	//		2° bi-lateral blur on generated shadow map
	////////////////////////
	OpenGLEngine::FBO shadowMap_FBO;
	shadowMap_FBO.addDepthRenderTarget(GL_DEPTH_COMPONENT32F, ShadowMap_width, ShadowMap_height, GL_DEPTH_COMPONENT, GL_FLOAT);
	shadowMap_FBO.addColorRenderTarget(GL_RGB32F, ShadowMap_width, ShadowMap_height, GL_RGB, GL_FLOAT);
	shadowMap_FBO.setColorAttachments();

	OpenGLEngine::FBO biLateralBlur_FBO;
	biLateralBlur_FBO.addColorRenderTarget(GL_RGB32F, ShadowMap_width, ShadowMap_height, GL_RGB, GL_FLOAT);
	biLateralBlur_FBO.setColorAttachments();

	////////////////////////
	// 1st pass: render depth map
	////////////////////////
	shadowMap_FBO.bindFBO();

	// render from light position
	glm::vec3 cameraPos = camera.getCameraPosition();
	camera.moveTo(vLight.value);

	OpenGLEngine::f2vUniform uNearFarPlane;
	uNearFarPlane.name = "uNearFarPlane";
	std::pair<float, float> near_far = camera.getNearFarPlane();
	uNearFarPlane.value = glm::vec2(near_far.first, near_far.second);
	uNearFarPlane.type = "f2v";

	shadowMapShader.Use();
	glEnable(GL_DEPTH_TEST);
	glDepthMask(GL_TRUE);
	// Clear all relevant buffers
	glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

	uNearFarPlane.linkUniform(&shadowMapShader);
	// draw scene (depth only)
	scene.drawMeshes(&camera, &window, &shadowMapShader);

	shadowMap_FBO.unbindFBO();

	////////////////////////
	// 2nd pass: blur depth map
	////////////////////////
	biLateralBlur_FBO.bindFBO();

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
	bilateralBlurShader.Use();

	// Active proper texture unit before binding
	shadowMap_FBO.bindTextureTargets();
	shadowMap_FBO.linkTextureTargets(&std::vector<std::string>{ "frag_depth" }, &bilateralBlurShader);

	// draw quad
	screenQuadGeometry.draw();

	biLateralBlur_FBO.unbindFBO();

	// Syncronyse
	glFinish();

	////////////////////////
	// Generate texture from FBO
	////////////////////////

	biLateralBlur_FBO.bindFBO();

	std::vector< float > shadowMap_rawData(3 * ShadowMap_width * ShadowMap_height);
	glPixelStorei(GL_PACK_ALIGNMENT, 1);
	glReadPixels(0, 0, ShadowMap_width, ShadowMap_height, GL_RGB, GL_FLOAT, shadowMap_rawData.data());

#ifdef DEBUG_SAVE_GEN_DATA
	std::vector< unsigned char > shadowMap_save(3 * ShadowMap_width * ShadowMap_height);
	glPixelStorei(GL_PACK_ALIGNMENT, 1);
	glReadPixels(0, 0, ShadowMap_width, ShadowMap_height, GL_RGB, GL_UNSIGNED_BYTE, shadowMap_save.data());
	std::string img_path = "Gen_Data/ShadowMap.bmp";
	SOIL_save_image(img_path.c_str(), SOIL_SAVE_TYPE_BMP, ShadowMap_width, ShadowMap_height, 3, shadowMap_save.data());
#endif

	glBindTexture(GL_TEXTURE_2D, ShadowMap_textureID);

	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, ShadowMap_width, ShadowMap_height, 0, GL_RGB, GL_FLOAT, shadowMap_rawData.data());

	glGenerateTextureMipmap(ShadowMap_textureID);

	glBindTexture(GL_TEXTURE_2D, 0);
	glFinish();

	biLateralBlur_FBO.unbindFBO();

	////////////////////////
	// Declare Texture uniform
	////////////////////////
	OpenGLEngine::Texture2D depthMap;
	depthMap.ID = ShadowMap_textureID;
	depthMap.name = "depthMap";
	depthMap.type = "sampler2D";

	OpenGLEngine::m4fUniform uLightSpaceMatrix;
	uLightSpaceMatrix.name = "uLightSpaceMatrix";
	near_far = camera.getNearFarPlane();
	uLightSpaceMatrix.value = glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f, near_far.first, near_far.second) * camera.getViewMatrix();
	uLightSpaceMatrix.type = "m4f";

	plane.addTexture(&depthMap);
	plane.addUniform(&uLightSpaceMatrix);

	// set the camera to its original position
	camera.moveTo(cameraPos);

	// add a cube representing the lights position
	OpenGLEngine::Geometry cube_geometry("CubeGeometry", 1, vLight.value);
	OpenGLEngine::Mesh light_cube(&cube_geometry, &OpenGLEngine::Material());
	scene.addMesh(&light_cube);

	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	// Create a renderbuffer object for depth and stencil attachment (we won't be sampling these)
	OpenGLEngine::RBO renderBuffer(window.getWidth(), window.getHeight());

	////////////////////////
	// 5°/ Render loop
	//	The render loop is pretty straight forward:
	//		- Loop until window is closed (Esc Key)
	//		- Update key & controler events
	//		- Render scene
	//		- Swap screen buffer and display the window
	//
	////////////////////////

	stopWatch timer; // FPS counter

	// Render loop
	while (window.isOpen())
	{
		timer.start();

		////////////////////////
		//	- Update Events
		////////////////////////
		// Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions
		window.updateEvents();
		//window::mouse.inertia();
		window.getControler()->inertia();

		////////////////////////
		//	- Render
		////////////////////////

		// Clear the colorbuffer
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
		glEnable(GL_DEPTH_TEST);

		////////////////////
		// Render Object
		////////////////////
		// 1st render pass: draw object as normal and fill stencil buffer
		scene.drawMeshes(&camera, &window);

		// Optional
		// 2nd render pass: now draw slightly scaled versions of the objects, this time disabling stencil writing.
		// Because stencil buffer is now filled with several 1s. The parts of the buffer that are 1 are now not drawn, thus only drawing
		// the objects' size differences, making it look like borders.
		//		scene.outlineMeshes(&stencilShader, &camera, &window);

		// Swap the screen buffers
		window.draw();

		// Syncronyse
		glFinish();

		timer.end();
		double render_time = timer.time();
		std::cout << "1F: " << 1000.0*render_time << "ms" << "," << "FPS: " << 1.0 / render_time << std::endl;
	}

	// Melete meshes
	// Properly de-allocate all resources once they've outlived their purpose
	// => done in mesh desctuctor

	window.isClosed();

	return 0;
}

redpajama_set_name: RedPajamaGithub


We are Commtap CIC and we are responsible for the running of this site (commtap.org). We also provide software for symbol communication.
If you log in to the Commtap site (commtap.org), the site will store some data related to you.
If you use software provided by Commtap, there may be some exchange of data between your computer and Commtap CIC's server.
This is an explanation of what this data is and why and when we store it.
a username - which can be anything you like.
Under the GDPR (General Data Protection Regulation 2018) our lawful basis for processing this data is our legitimate interests.
Specifically, we use your personal data to enable you to create a personal account. We also use this data to track the usage of the website which helps us to maintain and develop the site.
the area of that country you are based in.
This data is processed on the basis of our legitimate interests and helps us when we are talking to funders.
Please note, we do NOT provide any information that could identify you personally (e.g. an email address) to a third party (a person or organisation external to Commtap).
Please note, if you do not wish us to use this information, you do not need to provide it. You can also remove this information at any time.
Log in, click on your user name (top right), go to "My Settings" and also to "My Settings" -> "Optional Information".
You can delete your account completely by logging in, clicking on your username, going to "My Settings" and choosing "Delete Account" at the bottom of the page.
Contact us if you need any help with this.
To receive a copy of any information we hold about you.
You do not need to supply - and we do not ask for - any specific information where you are using the Commtap Symboliser on a trial basis without a license key.
To obtain a license key, in general you would purchase a license key from a company called FastSpring - who are based in the USA. We sell license keys to them, and they are authorised to sell license keys on to you. Once a purchase has been completed with FastSpring, we will be notified and will receive your name, company name (if applicable) and email address that you entered on their site. We store this information with your license key so that we can make sure that the software is being used only by those licensed to use it.
The time you last used the software.
You will also have the opportunity to send further information to Commtap about the error - but you do not have to.
From time to time we may contact you in relation to your use of the software - for example to tell you about important updates.
This data is processed on the basis of our legitimate interests.
You can contact us at the above address if you would like to view the information we have stored in relation to your installation and use of the Commtap Symboliser.
You can contact us if you would like us to remove this information. Please note: you may no longer be able to use the Commtap Symboliser after this information is removed.
We use the following services to store data. The providers do not have direct access to any data they hold on our behalf about you. Providers in the UK and the European Union conform to GDPR, the rest of the providers - based in the United States - demonstrate fulfilment of GDPR requirements through the Privacy Shield Framework.
1and1 - UK, Germany, European Union - GDPR compliance.
DropBox - US - GDPR Compliance - Compliance with EU-US Privacy Shield.
GoDaddy - US - GDPR Compliance - Compliance with EU-US Privacy Shield.
iBackUp - US - GDPR Compliance - Compliance with EU-US Privacy Shield.
If you delete your account on the Commtap website the associated data will be deleted with immediate effect. If you write to us asking us to delete your data, this may take up to a month from the receipt of your request.
Commtap backs up all of its data to insure against data loss. This data is not available for use on any of Commtap's websites. Backups are retained for up to three months before being deleted.


text:
RUS EST
The railroad, much like any other infrastructure, requires persistent investment and renovation. Support obtained from the Cohesion Fund ever since accession of Estonia to the European Union has enabled major repairs on hundreds of kilometers of railroad and surrounding infrastructure. Such repairs are ongoing as a large part of the railroad still dates back to the 1960s.
The objective of relevant investment projects is to ensure sustainable transportation. Priorities also include connecting environment friendly, low-noise, and low-carbon transportation systems, including inland waterways, maritime transport, harbors, and other different modes of transport as well as developing and improving airport infrastructures for the purpose of advancing sustainable regional and local mobility.
Electrification of Estonian Railways
Estonian Railways is a responsible company and next to our principal objective - provision of premium quality railroad infrastructure related services for the purposes of both carriage of passengers and carriage of goods - we seek to reduce the harmful effect that rail transport has on the environment. The electric railway is one of the most eco-friendliest modes of transport.
Estonia has set a goal of covering approximately 14% of the transportation's sectors energy use from renewable sources by 2030. One third of this capacity is planned to be covered by increased electric rail traffic volumes. Expansion of the electric railway calls for significant extension of relevant contact network.
Design work on the first sections of the electric railway commences in 2020 and relevant implementation will be carried out in 2020-2028.
More information on electrification plans is available in English.
Estonian Railways Ltd is a state-owned company and is responsible for the development, maintenance and administration of railway infrastructure.
Telliskivi 60/2, 15073 Tallinn
© 2021 Estonian Railways Ltd. All rights reserved.
This website uses cookies to manage selected sessions and preferences.

redpajama_set_name: RedPajamaCommonCrawl


Peel, core and slice cooking apples to layer in the sausage meat pie.
Make the shortcrust pastry. Roll out 2/3 of the pastry to line a 450 g /1 lb loaf tin.
Combine the sausage meat , onion, garlic, breadcrumbs and seasoning.
Spoon a little into the base of the tin, smooth over and top with a layer of olives and peperoni sausage.
Repeat all the layers until the ingredients are used up, finishing with the sausage meat mixture.
Roll out the remaining pastry to form a lid . Dampen the edge of the pastry with water and cover the pie with the pastry lid.
Trim and seal the edges and make a small hole in the centre to allow any steam to escape.
Use any pastry trimmings to make leaves to decorate the top of the pie .
Glaze with beaten egg and cook in a moderately hot oven for about 1 hour .


text:
Arts & SciencesGeology
Virginia Institute of Marine Sciences (VIMS)
Emeriti Faculty and Research Associates
Departments & Programs Departments & Programs * Graduate Study Offered Africana Studies American Studies * Anthropology * Applied Science * Art & Art History Biology * Business Chemistry * Classical Studies Computational & Applied Mathematics & Statistics Computer Science * Economics Education English Environmental Science & Policy Film & Media Studies Gender, Sexuality & Women's Studies Geology Global Studies Government History * International Relations Kinesiology & Health Sciences Linguistics Mathematics Medieval & Renaissance Studies Military Science Modern Languages Music Neuroscience Philosophy Physics * Psychological Sciences * Public Policy * Religious Studies Sociology Theatre, Speech & Dance All Majors and Minors
Steven A. Kuehl
Professor of Marine Science
Email: [[v|kuehl]]
Office: Holben House 104
Office Phone: 804 684 7118
B.A., Lafayette College ,1979
M.S., North Carolina State University, 1982
Ph.D., North Carolina State University, 1985
Primary research in my lab centers on sediment dispersal and the accumulation of fine-grained sediments in continental margin environments.
The formation of marine sedimentary strata rarely results from the simple settling of sedimentary material to the sea floor, but rather from the complex interaction of physical, chemical, and biological processes operating in the marine environment. These processes, such as resuspension and biological mixing, impart characteristic signatures to the sediment and control the burial and preservation of important sedimentary components such as organic carbon and anthropogenic materials. We are investigating the characteristics of recent sedimentary strata on spatial scales ranging from less than a mm to 100's of meters and on temporal scales from seconds to 1,000's of years in a variety of continental margin environments.
In addition to projects currently being carried out in Chesapeake Bay, I am also focused on sediment dispersal from tectonically active continental margins. Areas such as the North Island, New Zealand, which discharge huge volumes of sediment to narrow continental shelves where, presumably, active bypassing to the deep sea occurs.
"A Real-Time and Rapid Response Benthic Observing System for the Study of Physical and Biological Controls on Muddy Seabed Deposition" (Lead PI Friedrichs, with Harris, McNinch, Schaffner and Diaz). Funded by NSF-OCE
"Extension of Sediment Geochronology to Coarse-Grained Sediments". Funded by ONR.
"Resolution of the Stratigraphic Record for a High Input, Collision-Margin Shelf Basin: The MARGINS Waipaoa Focus Area". Funded by NSF-MGG.
"Sediment Dispersal off a High-Yield River: Observations and Modeling of Gravity-Driven Transport and Deposition." (Lead PI Kuehl, with Friedrichs, Harris, McNinch and Wright). Funded by NSF-OCE.
Kuehl, S.A., Allison, M.A., Goodbred, S.L. and Kudrass, H., 2005. The Ganges-Brahmaputra Delta, In: River Deltas - Concepts, Models, and Examples (L. Gosian and J. Bhattacharya, eds.), SEPM Special Publication No. 83, p. 413-434.
Kuehl, S.A., Brunskill, G.J., Burns, K., Fugate, D., Kiniskern, T. and Meneghini, L., 2004. Nature of sediment dispersal off the Sepik River, Papua New Guinea: preliminary sediment budget and implications for margin processes, Continental Shelf Research, 24:2417-2429.
Kuehl, S.A., Carter, L., Gomez, B. and Trustrum, N., 2003, Holistic Approach Offers Potential to Quantify Mass Fluxes Across Continental Margins, Eos, 84, No. 38, 379/388.
Kniskern, T.A., and S.A. Kuehl, 2003. Spatial and temporal variability of seabed disturbance in the York River subestuary, Estuarine, Coastal and Shelf Science, 58: 37-55.
Dellapenna, T.M., Kuehl, S.A., and Schaffner, L.C., 2003. Ephemeral deposition, seabed mixing and fine-scale strata formation in the York River estuary, Chesapeake Bay, 58: 621-643.
Goodbred, S.L. and Kuehl, S.A., 2003. The production, transport, and accumulation of sediment: a cross-section of recent developments with an emphasis on climate effects, Sedimentary Geology, 162: 1-3.
Allison, M.A., Khan, S.R., Goodbred, S.L., and Kuehl, S.A., 2003. Stratigraphic evolution of the late Holocene Ganges-Brahmaputra lower delta plain. Sedimentary Geology, 155: 317-342.
Goodbred, S.L., Kuehl, S.A., Steckler, M.S., and Sarker, M.H., 2003. Controls on facies distribution and stratigraphic preservation in the Ganges-Brahmaputra delta sequence. Sedimentary Geology, 155: 301-316.
Heroy, D.C., Kuehl, S.A., and Goodbred, S.L., 2003. Mineralogy of the Ganges and Brahmaputra Rivers: implications for river switching and Late Quaternary climate change. Sedimentary Geology, 155: 343-359.
Neubauer, S.C., Anderson, I.C., Constantine, J.A., and Kuehl, S.A., 2002. Sediment deposition and accretion in a Mid-Atlantic (U.S.A.) tidal freshwater marsh. Estuarine, Coastal and Shelf Science, 54:713-727.
Orpin, A.R., Carter, L., Kuehl, S.A., Trustrum, N.A., Lewis, K.B., Alexander, C.R., and Gomez, B., 2002. Deposition from very high sediment yield New Zealand rivers is captured in upper margin basins. MARGINS, 9:1-4.
Dellapenna, T.M., Kuehl, S.A., and Pitts, L, 2001. Transient, longitudinal, sedimentary furrows in the York River subestuary, Chesapeake Bay: Furrow evolution and effects on seabed mixing and sediment transport. Estuaries, 24:215-227.
Smith and Kuehl, S.A., 2001. Physical energy regimes, seabed dynamics and organism-sediment interactions along an estuarine gradient. In: J.Y. Aller, S.A. Woodin and R.C. Aller (eds.), Organism-Sediment Interactions, University of South Carolina Press, Columbia, SC. Belle W. Baruch Library in Marine Science, no. 21.
Goodbred, S.L. and Kuehl, S.A., 2000. Enormous Ganges-Brahmaputra sediment discharge during strengthened early Holocene monsoon. Geology, 28:1083-1086.
Kineke, G.C., Woolfe, Kuehl, S.A., Milliman, J.D., Dellapenna, T.M., and Purdon, R.G., 2000. Sediment export from the Sepik River, Papua New Guinea: Evidence for a divergent dispersal system. Continental Shelf Research, 20:2239-2266.
Goodbred, S.L. and Kuehl, S.A., 2000. The significance of large sediment supply, active tectonism and eustasy on margin sequence development: Late Quaternary stratigraphy and evolution of the Ganges-Brahmaputra delta. Sedimentary Geology, 133:227-248.
Dellapenna, T.M., Kuehl, S.A., and Schaffner, L.C., 1998. Seabed mixing and particle residence times in biologically and physically dominated estuarine systems: A comparison of lower Chesapeake Bay and the York River subestuary. Estuarine, Coastal and Shelf Science, 46:777-795.
Courses Taught/Teaching
MSCI 623 - Isotope Geochronlogy
GEOL 306 - Marine Geology
MSCI 698 - Topics in Marine Science: Sediment Dating
MSCI 501C - Fundamentals of Marine Science
MSCI 501L - Geological Oceanography Lab
MSCI 698 - Topics in Marine Science: New Zealand Rivers
MSCI 698 - Topics in Marine Science: 210Pb Geochronology
MSCI 698 - Topics in Marine Science: Be-7 in the Marine Environment
MSCI 545 - Marine Sedimentation
MSCI 698 - Continental Margin Sedimentation
MSCI 622 - Quaternary Evolution of Coastal Environments
MSCI 698 - Advanced Topics in Radioisotope Geochronology
Faculty/Student Awards
1997 VIMS/SMS Outstanding Teacher Award.
Energy Minerals Division Certificate of Excellence for poster presentation, American Association of Petroleum Geology Annual Meeting, Calgary, 1992.
Certificate of Recognition from NASA/ASEE for research contributions made through the 1991 Summer Faculty Fellowship Program.
Geological Society of America
Society for Sedimentary Geology
Collaborative/Interdisciplinary Efforts
MARGINS S2S Program (http://www.margins.wustl.edu)
COOP Program (http://www.skio.peachnet.edu/coop)


Life should be a tidal tour. Are you new to the recreation of kayaking? Unaware of the amount of energy or efficiency needed to give this a try? This tour is for you, as is was for me in the beginning. Tide goes out, you go with it. Tide comes in, you come in with it. Sort of "wax on, wax off" as the "kayak sensei" would say.
Parker River Tour is our tidal tour destination.
Easy, relaxed, and a beginners dream come true.


Aiming for comment-worthy style at your home bar? Nailed it. The Areaware Bottle Opener functions with a single, striking bent nail, which serves as a lever to pry open your favorite refreshment. One magnet catches the bottle cap while another allows you to hang the entire device on whatever cool, magnetic surface is closest at hand. In clean-and-light beech wood, this is a bar essential that's as welcome as that perfect brew you've been craving all afternoon.
Dimensions: 4.5" L x 1.5" W x .75" D.


The Beach banner Round is ideal for square or round logos. Quick to set up and easy to transport. Available in three sizes.
If you only want to have your company logo on the Beach banner Round please send it to us (.AI, .EPS file). We provide a digital example for you for free!


text:
Q: Как "согнуть" SeekBar? Есть стандартный SeekBar, при помощи чего его можно "согнуть" под углом?

Сам SeekBar
<SeekBar
        android:id="@+id/seekBar"
        android:layout_width="100dp"
        android:layout_height="30dp"
        android:padding="10dp"
        android:progressDrawable="@drawable/dot"
        android:thumb="@drawable/sun" />

A: Мне кажется стандартным компонентом не получится. Используйте для этого лучше библиотеку SeekArc. Иконку Солнца как нибудь кастомизируете. А для получения полукруга поиграйтесь с seekarc:startAngle и seekarc:sweepAngle.
Думаю получите полукруг таким образом:
seekarc:startAngle="90"
seekarc:sweepAngle="270"

A: Вы можете взять код из библиотеки SeekArc и минимально модифицировать его для вашего случая. Библиотека идёт под лицензией MIT, что фактически разрешает Вам делать с кодом что угодно.
В файле SeekArc.java есть метод onDraw, который, собственно, и делает всю магию:
@Override
protected void onDraw(Canvas canvas) {
    if(!mClockwise) {
        canvas.scale(-1, 1, mArcRect.centerX(), mArcRect.centerY() );
    }

    // Draw the arcs
    final int arcStart = mStartAngle + mAngleOffset + mRotation;
    final int arcSweep = mSweepAngle;
    canvas.drawArc(mArcRect, arcStart, arcSweep, false, mArcPaint);
    canvas.drawArc(mArcRect, arcStart, mProgressSweep, false,
            mProgressPaint);

    if(mEnabled) {
        // Draw the thumb nail
        canvas.translate(mTranslateX - mThumbXPos, mTranslateY - mThumbYPos);
        mThumb.draw(canvas);
    }
}

В качестве mThumb установите drawable вашего солнышка.
mArcPaint -- это как раз то, что вам нужно поменять используя метод setPathEffect. Здесь есть пример, где используются пунктирные линии для прямой и произвольной ломаной (более чистый пример создания объекта Paint есть также тут).
В данном случае Вы так же можете применить DashPathEffect к объекту mArcPaint для рисования кривой методом drawArc. Вероятно, Вам так же потребуется удалить строку, которая рисует прогресс:
 canvas.drawArc(mArcRect, arcStart, mProgressSweep, false, mProgressPaint);

Просто добавьте файл в Ваш проект и внесите нужные изменения.

A: Привет. Если вы хотите создать такой SeekBar (звезда + орбита) то у вас ничего не выйдет. Вам нужно создавать кастомный элемент и на нем самостоятельно менять местоположение звезды в зависимости от значений.

redpajama_set_name: RedPajamaStackExchange