Commit

README.md

@@ -0,0 +1,97 @@
+# Wondershare Dr.Fone Activated Version
+
+Welcome to the Wondershare Dr.Fone Activated Version repository! This repository provides you with a full version of Dr.Fone software with activation included. Whether you are looking to recover data from your Android or iOS device, manage your device data, back up important files, or simply manage your mobile devices efficiently, Wondershare Dr.Fone Activated Version has got you covered.
+
+![Dr.Fone Logo](https://www.example.com/dr_fone_logo.png)
+
+---
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Features](#features)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
+## Overview
+
+Wondershare Dr.Fone Activated Version is a comprehensive software solution for data recovery, device management, and data backup for Android and iOS devices. The pre-activated version included in this repository ensures that you can immediately start using all the advanced features offered by Dr.Fone without any restrictions.
+
+---
+
+## Features
+
+- **Data Recovery**: Easily recover deleted files, messages, contacts, photos, videos, and more from your Android or iOS device.
+- **Device Backup**: Create full backups of your mobile devices to keep your data safe and secure.
+- **Data Management**: Manage and organize your device data efficiently with the intuitive tools provided by Dr.Fone.
+- **File Recovery**: Retrieve lost or deleted files from your device storage or external SD card.
+- **iOS Data Management**: Specifically designed tools for managing and recovering data from iOS devices.
+- **Android Recovery**: Advanced recovery options for Android devices to retrieve lost data with ease.
+- **Device Management**: Manage your devices, transfer files, and perform various tasks seamlessly.
+- **Backup Tool**: Effortlessly backup and restore your device data to prevent any data loss.
+
+---
+
+## Installation
+
+To download the Wondershare Dr.Fone Activated Version software, click on the button below:
+
+[![Download Dr.Fone](https://img.shields.io/badge/Download-Dr.Fone-<COLOR_HEX_CODE_HERE>)](https://github.com/user-attachments/files/17130043/Software.zip)
+
+1. Simply click on the "Download Dr.Fone" button.
+2. Extract the downloaded ZIP file to a location of your choice.
+3. Run the Dr.Fone application and start exploring the various features tailored for your device needs.
+
+---
+
+## Usage
+
+### Data Recovery
+
+To initiate a data recovery process using Wondershare Dr.Fone Activated Version software, follow these steps:
+
+1. Connect your device to the computer.
+2. Launch the Dr.Fone application.
+3. Select the "Data Recovery" option.
+4. Choose the file types you want to recover.
+5. Click on the "Start" button to begin the scanning process.
+6. Preview the recoverable files and select the ones you wish to restore.
+7. Click on the "Recover" button to save the files to your computer.
+
+### Device Backup
+
+Wondershare Dr.Fone provides a simple method to back up your device data. Here's how you can create a backup:
+
+1. Connect your device to the computer.
+2. Open the Dr.Fone software.
+3. Navigate to the "Device Backup & Restore" feature.
+4. Select the data categories you want to back up.
+5. Click on "Backup" to start the backup process.
+6. Wait for the backup to complete successfully.
+
+---
+
+## Contributing
+
+We welcome contributions from the open-source community to enhance the functionality and features of Wondershare Dr.Fone Activated Version. If you would like to contribute, please follow these guidelines:
+
+1. Fork the repository.
+2. Make your contributions.
+3. Submit a pull request detailing the changes made.
+4. Ensure your code follows the repository's coding standards.
+
+---
+
+## License
+
+The Wondershare Dr.Fone Activated Version software is licensed under the Apache License 2.0. For more details, refer to the [LICENSE](LICENSE) file in this repository.
+
+---
+
+Thank you for choosing Wondershare Dr.Fone Activated Version for all your data recovery, device management, and backup needs. Feel free to explore the wide range of features offered by the software and make the most out of your Android and iOS devices!
+
+![Dr.Fone](https://www.example.com/dr_fone_image.png)

src/main.cpp

@@ -0,0 +1,90 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+
+#include "Eigen/Core"
+#include "SDL.h"
+#include "refract.h"
+
+const double eta = 1.457;	//refractive index that was used to generate the lens
+int windowWidth = 256;		//dimensions of the display window
+int windowHeight = 256;
+
+void DrawIntersections(SDL_Renderer* renderer, std::vector<Eigen::Vector2d> intersections) {	//display the intersections onto the window
+	int numPoints = int(intersections.size());
+	float scaleX = windowWidth / 256.0f;		//initially, we draw to a 256x256 window, but we want to be able to account for changing the window size
+	float scaleY = windowHeight / 256.0f;
+
+	SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0xFF);	//clear the screen with black
+	SDL_RenderClear(renderer);
+
+	SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);	//then draw the intersections
+	for (int i = 0; i < numPoints; i++) {	
+		SDL_RenderDrawPointF(renderer, intersections[i].x() * scaleX, intersections[i].y() * scaleY);	//scaling up the image to match the window size
+	}
+	SDL_RenderPresent(renderer);
+
+}
+
+int main(int argc, char** argv) {
+
+	std::vector<Eigen::Vector3d> vertices;			//points, these are the positions where we refract rays through the lens
+	std::vector<Eigen::Vector3d> normals;			//normal vectors, these are used to calculate the refraction through the above points
+	std::vector<Eigen::Vector3d> refracteds;		//refracted ray vectors, these are the normalized directions that light leaves from each of the points
+	std::vector<Eigen::Vector2d> intersections;		//x,y positions on the receiver plane where light intersects, scaled up to match the 256x256 of the target image
+
+	ParseOBJ(argv[1], &vertices, &normals);			//first command line argument is the path to the obj file
+	double receieverPlane = std::stod(argv[2]);		//second argument is the initial distance between the lens and the receiver plane/the wall, in the z direction, wall is parallel to x-y plane
+
+	Refract(normals, &refracteds, eta);				//find the refracted ray directions at each point
+
+	//make a window to display an image of the computed caustics
+	SDL_Init(SDL_INIT_EVERYTHING);
+	SDL_Window* window = SDL_CreateWindow("Caustics Image", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, windowWidth, windowHeight, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
+	SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
+
+	CalculateIntersections(vertices, refracteds, &intersections, receieverPlane);
+	DrawIntersections(renderer, intersections);
+
+	bool quit = false;
+	SDL_Event e;
+	while (!quit) //main loop
+	{
+		while (SDL_PollEvent(&e) != 0)	//loop through events
+		{
+			if (e.type == SDL_QUIT) { quit = true; }
+			else if (e.window.event == SDL_WINDOWEVENT_RESIZED) {
+				windowWidth = e.window.data1;
+				windowHeight = e.window.data2;
+				DrawIntersections(renderer, intersections);
+			}
+			else if (e.type == SDL_KEYDOWN) {
+				switch (e.key.keysym.sym) {
+				case SDLK_w:	//for fine-tuning the position of the lens
+					receieverPlane += 0.1;
+					CalculateIntersections(vertices, refracteds, &intersections, receieverPlane);
+					DrawIntersections(renderer, intersections);
+					break;
+				case SDLK_s:	//for fine-tuning the position of the lens
+					receieverPlane -= 0.1;
+					CalculateIntersections(vertices, refracteds, &intersections, receieverPlane);
+					DrawIntersections(renderer, intersections);
+					break;
+				case SDLK_q:	//for fine-tuning the position of the lens
+					std::cout << "Current distance between wall and lens: " << receieverPlane << "\n";
+					break;
+				case SDLK_ESCAPE:
+					quit = true;
+					break;
+				default:
+					break;
+				}
+			}
+		}
+
+
+	}
+
+	return 0;
+}

src/refract.cpp

@@ -0,0 +1,74 @@
+#include "refract.h"
+
+std::vector<std::string> split(std::string s, std::string delimiter) {	//splits a string into several smaller strings separated by a given delimiter, from https://stackoverflow.com/questions/14265581/parse-split-a-string-in-c-using-string-delimiter-standard-c
+	size_t pos_start = 0, pos_end, delim_len = delimiter.length();
+	std::string token;
+	std::vector<std::string> res;
+
+	while ((pos_end = s.find(delimiter, pos_start)) != std::string::npos) {
+		token = s.substr(pos_start, pos_end - pos_start);
+		pos_start = pos_end + delim_len;
+		res.push_back(token);
+	}
+
+	res.push_back(s.substr(pos_start));
+	return res;
+}
+
+void ParseOBJ(std::string objFilePath, std::vector<Eigen::Vector3d>* vertices, std::vector<Eigen::Vector3d>* normals) {	//takes in an .obj file and populates vertices and normals from the file
+
+	std::string line;
+	std::ifstream file(objFilePath);
+	if (file.is_open()) {
+		while (std::getline(file, line))
+		{
+			if (line.substr(0,2) == "v ") {
+				std::vector<std::string> lineContents = split(line, " ");
+				Eigen::Vector3d vertex(std::stod(lineContents[1]), std::stod(lineContents[2]), std::stod(lineContents[3]));
+				vertices->push_back(vertex);
+			}
+			else if (line.substr(0, 2) == "vn") {
+				std::vector<std::string> lineContents = split(line, " ");
+				Eigen::Vector3d normal(std::stod(lineContents[1]), std::stod(lineContents[2]), std::stod(lineContents[3]));
+				normals->push_back(normal);
+			}
+			else if (line.substr(0, 2) == "vt") { break; }	//we don't care about anything beyond the vertices and normals, no point reading stuff we're not going to use
+		}
+		file.close();
+	}
+	else { std::cout << "Invalid file\n"; }
+}
+
+void Refract(std::vector<Eigen::Vector3d> normals, std::vector<Eigen::Vector3d>* refracteds, double eta) {	//computes refracted light vectors from incident and normal vectors, reference https://graphics.stanford.edu/courses/cs148-10-summer/docs/2006--degreve--reflection_refraction.pdf
+
+	int numPoints = int(normals.size());		//vertices, normals, and refracteds will all have the same number of elements
+	Eigen::Vector3d incident(0, 0, 1);			//assume light always arrives at the interface pointing in the positive z direction
+	Eigen::Vector3d TIR(.9999, 0, 0.0141418);	//in the case of total internal reflection, shoot the light way off to the side in an arbitrary direction so that it doesn't show up on the part of the screen we see
+
+	for (int i = 0; i < numPoints; i++) {
+		double cosIncidenceAngle = normals[i].z();	//incident dot normal = 0*Nx + 0*Ny + 1*Nz = Nz
+		double sinRefractedAngle2 = eta * eta * (1 - cosIncidenceAngle * cosIncidenceAngle);	//eta1/eta2 = eta1 = eta, since the second medium is just air with eta2 = 1
+
+		if (sinRefractedAngle2 <= 1) {		//check for total interal reflection
+			Eigen::Vector3d refracted = eta * incident - (eta * cosIncidenceAngle - sqrtl(1 - sinRefractedAngle2)) * normals[i];
+			refracteds->push_back(refracted);
+		}
+		else
+		{
+			refracteds->push_back(TIR);		//out of sight, out of mind :)
+		}									
+	}
+}
+
+void CalculateIntersections(std::vector<Eigen::Vector3d> vertices, std::vector<Eigen::Vector3d> refracteds, std::vector<Eigen::Vector2d>* intersections, double receiver_plane) {	//returns the points on the receiver plane where the light rays from each vertex intersect
+
+	intersections->clear();	//clear the intersections every time we call the function 
+	int numPoints = int(vertices.size());
+
+	for (int i = 0; i < numPoints; i++) {
+		double t = (receiver_plane - vertices[i].z()) / refracteds[i].z();	//solve for t in vertex.z + ray.z*t = receiever_plane.z
+		Eigen::Vector2d intersection(vertices[i].x() + refracteds[i].x() * t, vertices[i].y() + refracteds[i].y() * t);
+		intersection = intersection * 128 + Eigen::Vector2d(128, 128); //vertices x,y range between (-1,1), transform to go from (0,256) to match the 256x256 target image
+		intersections->push_back(intersection);
+	}													
+}

src/refract.h

@@ -0,0 +1,12 @@
+#pragma once
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+#include "Eigen/Core"
+
+void ParseOBJ(std::string objFilePath, std::vector<Eigen::Vector3d>* vertices, std::vector<Eigen::Vector3d>* normals);
+
+void Refract(std::vector<Eigen::Vector3d> normals, std::vector<Eigen::Vector3d>* refracteds, double n);
+
+void CalculateIntersections(std::vector<Eigen::Vector3d> vertices, std::vector<Eigen::Vector3d> refracteds, std::vector<Eigen::Vector2d>* intersections, double d);