In late 2012, iFixit.com posted a teardown of the MacBook Pro 13″ Retina Display Late 2012 and noted that:

• The most striking layout change resulting from the shrink from a 15″ to 13″ form factor is the rearranged battery cells. This allowed Apple’s designers to cleverly tuck the SSD away underneath the trackpad assembly.
• The empty space next to the SSD is very un-Apple. It’s not like them to leave big air gaps in their newest, sleekest designs.
• Our first thought was that a standard 2.5″ laptop drive might fit in this space, and it almost looks like this little nook was designed with that in mind.
• Our 9.5mm Crucial SSD didn’t allow the bottom cover to be closed, but just by a smidge. We’ll see if a 7 mm or 5 mm super-slim hard drive could be incorporated into the space.

iFixit later posted a guide to replacing the SSD in early 2013, but at the time, the only SSD alternatives appeared to be 3rd party modules like the Transcend JetDrive ($280 for 480GB drive and external USB 3.0 case) or the OWC Aura ($218 for 480GB drive only).

These 3rd party options, which have been designed specifically for the MacBook Pro’s SSD form factor, have been outside of my price range. However, recently, I’ve seen adapters available that would allow me to use smaller form factor SSDs with my A1425 MacBook Pro. For example:

• mSATA SSD to MacBook Pro Retina (A1425 A1398) Adapter (Amazon, DX)
• M.2 SSD to MacBook Pro Retina (A1425 A1398) Adapter (Amazon, DX)

Combine these adapters with either a Samsung 850 EVO mSATA SSD or a Transcend M.2 SSD (respectively) and you could potentially upgrade the SSD for significantly less than the designed-from-scratch modules offered by Transcend and OWC. I researched the adapters a bit more and found that if I chose to go the M.2 route, that I would need to make sure the new drive was SATA rather than PCIe (such as the Samsung 950 PRO). At the end of the day, I ordered a M.2 SSD to MacBook Pro Retina (A1425 A1398) Adapter and a 512GB Transcend M.2 SSD from Amazon and decided to see if I could get it up and running.

I wasn’t sure if there were going to be any performance gains/penalties, so I checked the speed of the original OEM 256GB SSD using Blackmagic Disk Speed Test:

Not too bad.

When I received the adapter and new SSD in the mail, I backed up my old SSD onto an external drive using Time Machine. I also created an El Capitan boot drive so that I could wipe the old drive and restore the Time Machine backup to the new SSD. I erased the old drive and although I tried securely wiping the drive, there are some lingering issues with wiping SSDs. Now I was ready for the transplant. Using the iFixit SSD Replacement guide, I removed the old SSD in preparation for the new module.

The M.2 drive fit perfectly into the adapter:

And I threw the whole shebang into the MacBook’s drive caddy:

After reassembling the machine, I started up the computer using the boot disk and… It worked. Awesome. I restored the time machine backup onto the new drive and it booted up without any issues. One little hiccup is that Apple disables TRIM for 3rd party SSDs, so you need to make sure to enable it after-the-fact using trimforce. It’s also faster than the original OEM SSD:

If you have an older MacBook Pro that’s running out of space, this is an easy and very worthwhile upgrade.

http://www.youtube.com/watch?v=bLxYTT_0GEI

I tried my hand at processing the HDR video output and was able to get a reasonably nice tone-mapped video:

After the break, you’ll find how I processed the initial Magic Lantern video using MATLAB and exiftool and tone-mapped the output using Luminance HDR.

First, we need to process the video with a function I (poorly) named ‘Step1MovieToInterpolatedFrames.m’ to separate the dark and light frames. The video is first loaded using the VideoReader object. Then we check to see if the first frame is darker or lighter than the second. This is admittedly a bit of a hack, but given the gross differences in exposure, seems to work well enough. After determining whether the first is light or dark, we then loop through all the frames of the movie, saving the real frames and appending an “L” to signify they are “light” and, also, interpolate between the frames. Why go through the bother of interpolation? Well, there will be image registration problems with the tone-mapping if we assume that a given dark frame matches the earlier or later light frame, especially with high-speed motion. Interpolation helps us “smooth” these errors out. Note that ideally we would use a morphing algorithm (similar to the one used by Twixtor), but this is the quickest method for the time being. After saving each frame, I use exiftool to assign an aperture value. Note that this has nothing to do with the real aperture value, but helps Luminance HDR tonemap the composite image. We do this for the dark frames as well, but now we take into account the EV shift in the video’s ISO when writing the aperture value using exiftool.

The second function, ‘Step2FramesToHDRFrames.m’, takes the individual light and dark frames and generates tone-mapped images. We go through every frame and use the Luminance HDR CLI (command line interface) to generate an HDR image and tone-map it (here using the mantiuk08 tone-mapping operator).

And the final function (‘Step3HDRFramesToVideos.m’) compiles all of the tone-mapped images into videos (one for the light frames, one for the dark frames, and one for the tonemapped frames).

The code can be found at the bottom of the post.

So, what do each of the Luminance HDR tonemapping operators look like (with their default parameters) when applied to a video? Here’s the source (note that YouTube strips out the alternating frames, you can find the original MOV here):

Ashikhmin

Drago

Durand

Fattal

Mantiuk 06

Mantiuk 08

Pattanaik

Reinhard 02

Reinhard 05

So the question is: What do I need to do to get this 3D object printed at Shapeways? Click through to see the steps that I took to get this 3D model printed economically.

Since the object generation script creates a MATLAB struct with vertices and faces, I was able to use the vertface2obj script by Anders Sandberg to export .obj files. Here is the object at a variety of resolutions in .obj format:

• 162 vertices (12 KB)
• 642 vertices (41 KB)
• 2562 vertices (160 KB)
• 10242 vertices (659 KB)
• 40962 vertices (2.8 MB)

These .obj files can be imported directly into Shapeways. After importing, Shapeways runs a series of sanity checks to make sure that the file can be printed and then posts it on their site. Here’s a link to one such imported object.

Notice the price? (~$63 for a plastic print) Whoa! That’s a lot more than I wanted to pay for a simple blob model.

It turns out that the cost of printing a model at Shapeways is proportional to the model’s volume (source):

Our pricing is based upon the actual amount of material used in your product and the material you choose to use. So, the actual volume of your finished product not the volume of the bounding box determines the price.

So, the way to print this shape economically is to reduce the volume of the print. Shapeways suggests a couple of ways to reduce the cost of the 3D print, including hollowing out the model and carving it to reduce the total surface area. Using OpenSCAD, I was able to do both.

OpenSCAD allows for the importation of .stl files, which is another “standard” 3D file format. Using the stlwrite script, I was able to export my faces/vertices from MATLAB to a file that could be imported into OpenSCAD. Here’s the previously illustrated example file at a variety of resolutions in .stl format:

• 162 vertices (16 KB)
• 642 vertices (66 KB)
• 2562 vertices (258 KB)
• 10242 vertices (1 MB)
• 40962 vertices (4.1 MB)

Let’s work with the 10242 vertices file, “0431630057_sphere_tri_5.stl“. First, we can import it into OpenSCAD using:

Then we can do a “difference” between the object and a downscaled version to create the shell using (note that the % “background modifier” is used to make the bounding object transparent gray):

So we now have a shell, but let’s get rid of some more of the material by carving out a lattice of packed spheres. First, we will create a lattice of spheres (I just used the description on the Wikipedia page to create some simple procedural generation code):

Now we subtract the lattice from the shell that was previously generated, again using the difference command:

This would normally be the end of the process and you could then save the .stl and import it into Shapeways. However, all of the OpenSCAD coding turned out to be a useless garden path because the OpenSCAD computation took far too long and too much memory to process when using higher resolution base shape files and higher resolution spheres (repeatedly crashing when I tried to compile the code).

So, I tried an alternative route… Blender. Let’s replicate the steps above in Blender’s Python scripting interface. First, import0431630057_sphere_tri_5.stl into Blender:

Then, duplicate the object, reduce its scale, and take the boolean difference between the copy and the original to create a shell:

Then we create a lattice of spheres:

And finally, take the boolean differences between the shell and the spheres. Putting it all together:

This workflow uses up a lot less memory than the OpenSCAD route, but the processing time is still painfully slow. Thankfully though, it does not crash the compiler. To monitor the progress of the process, I simply run the script from the command line using “blender –background –python ‘SCRIPTLOCATION'”. I used the same bit of code as described above to create the “production quality” model, but used a higher resolution base shape (0431630057_sphere_tri_6.stl), higher resolution spheres (sphereSubdivisions = 5;), and a higher spatial resolution lattice (r = 0.1;). I saved it using:

After importing the object at Shapeways, we see that we can save a serious chunk of change on printing the new, modified model. Here is a link to the new and improved product on Shapeways, now only $3.66 (vs. $63.54) for the White Strong & Flexible Material.

In addition, I tried recompressing the image to see the effect of repeated JPEG compression on the output. An initial image is loaded, it is compressed, then that image is loaded and compressed at a lower quality, then that image is loaded and compressed at an even lower quality, and so on and so forth. Here’s the output at 10 frames per second when we do this from the least amount of JPEG compression (‘Quality’,100) to the most amount of compression (‘Quality’,0):

Just to be artistic, we can then repeat the cycle 10x and observe the effect of repeated compression. Here is an example at 30 frames per second with 10 loops of the repeated recompression:

Click through for the MATLAB code and a couple more example videos.

Here is the MATLAB code for illustrating increasing compression:

And two more examples:

Here is the MATLAB code for illustrating repeated compression:

And two more examples:

And finally, here is the MATLAB code for illustrating repeated compression (repeated 10 times):

And two final examples:

I recently switched from Verizon Wireless to AT&T. I have wanted a PDA phone for quite a while and Verizon never had any that seemed to satisfy my needs for an afforable price (I tried the Motorola Q9m and the HTC SMT5800, but both were large and difficult to pocket). After weighing all of the options (Sprint has been floundering, T-mobile doesn’t have the rural coverage I want and need, and the MVNOs just don’t have the support that I’m looking for), I decided to try out the iPhone with AT&T.

I picked up a refurb at an Apple store in my area for about the same price as a new iPod touch and instantly fell in love with the device. The screen is beautiful and the features are just what I wanted and needed. Although I am paying more than cell-only service ($60 vs. $45), I am paying quite a bit less than I would have with VZW ($60 vs. $85). After 4 1/2 years with VZW, I switched to AT&T for the iPhone and haven’t looked back.

So, after playing with the phone for a bit and trying out some web apps (I tried to make a wine pairing web app using information screen-scraped from an interesting web site and a Virginia Wine Showcase Classic Wine Pairings handout), I decided to jailbreak my iPhone. Wow. If you have an iPhone or iPod touch, don’t wait. Honestly, it has become 10x more fun now that I can play with the innerworkings!

So, getting back on focus with this article, I wanted some software that would “phone home” if it was stolen. There have been some interesting stories of people who have had their Macbooks, iMacs, and even Xboxes stolen and recovered due to monitoring software, so I thought I’d give it a try!

Using Erica Sadun’s findme-muchbetter and pingwifi binaries and Fuel’s great WeeGee anti-theft package, I put together a system that sends a message to a private twitter account detailing the iPhone’s location and will send emails to me with the cell phone’s contents (call history, SMS history, web history, location, and pictures) if it is stolen (which I trigger by changing a value on a website).

So, if you’re interested, here’s the package, boodle_dr1r1.zip, and the readme:

Boodle DR1r1
Code based on WeeGee v0.01 by Fuel, which was based upon mailsend and squide source code

NOTE: All code is copyrighted unless explicitly stated otherwise. Although my modifications were made under the assumption that the code is distributed under an open-source license and all modified code is available without license legalese, it may still be protected, so do not modify or distribute without acknowledging the authors! All efforts have been made to acknowledge the original authors and their contributions when possible.

ABOUT

Boodle is a simple script for iPhone firmware 1.1.4 that allows a user to monitor his/her iPhone’s location using Twitter and to potentially recover information about the phone via email once it is marked as stolen (calls, SMS, web history, and photos taken).

THIS IS ONLY MEANT FOR PERSONAL USE. NOTE: No anti-theft device is perfect and any protection scheme can be circumvented with a little effort, so DO NOT assume that you will be able to retrieve your iPhone (or any of the information stored within) if it is stolen. The author(s) of the scripts and software in the package shall have no liability to any persons or entities with respect to any loss, liability, or damage caused by the software package (i.e., if your iPhone is stolen, don’t assume that you will be able to track it down with this software). Install ONLY if you are the owner of the phone and are willing to assume responsibility for installing unstable software. PLEASE USE RESPONSIBLY.

REQUIREMENTS

A jailbroken iPhone (I recommend iLiberty+) with BSD Subsystem and Erica’s Ported Utilities installed. In addition, 4 helper applications need to be downloaded and placed in the /var/root/bin/boodle/ folder (see DOWNLOADS NECESSARY).

DOWNLOADS NECESSARY

mailsend from http://iphone.natetrue.com/FuelUtils/
Command line utility that sends mail in the background. Boodle uses this binary to send your data to you. Place this in /var/root/bin/boodle/

reduceJPEG from http://iphone.natetrue.com/FuelUtils/
Command line utility that resizes JPEGs to save time when uploading. Place this in /var/root/bin/boodle/

pingwifi from http://ericasadun.com/ftp/TUAW/findme/
Command line utility that pings the wifi so that the location of the phone can be calculated when it is asleep. Place this in /var/root/bin/boodle/

findme-muchbetter from http://ericasadun.com/ftp/TUAW/findme/
Command line utility that gets location information. Place this in /var/root/bin/boodle/

INCLUDED FILES

boodle.sh
This is the main script that does the work. Place this in /var/root/bin/boodle/

findLocation.sh
A helper script that is used to query findme-muchbetter depending on the type of location information saught (wifi/cell/ip). Place this in /var/root/bin/boodle/

com.semifluid.boodle.plist
Tells the iPhone to run the script every hour. Place this in /System/Library/LaunchDaemons/

CONFIGURING BOODLE.SH

At the top of the script, there are a number of variables you need to configure:

watchResponse – The command to query the server.
workPath – Path for files. Default is /var/root/bin/boodle
mailsendPath – Path for mailsend binary. Default is $workPath/mailsend
resizePath – Path for reduceJPEG binary. Default is $workPath/reduceJPEG
findmePath – Path of findme-muchbetter binary. Default is $workPath/findme-muchbetter
pingwifiPath – Path of pingwifi binary. Default is $workPath/pingwifi
smtpServer – Mail server IP address. Default is 64.233.167.109 (GMail).
smtpServerPort – Mail server port. Default is 587.
emailUsername – SMTP Username
emailPassword – SMTP Password
toEmail – Email address to send reports to when phone receives “stolen” command
JPEGMaxWidth – Max width or height of image. Default is 800.
JPEGQuality – JPEG quality (1-100). Default is 75.
trackLocation – Set to true to send updates to Twitter every time script is run (once per hour, by default)
twitterUsername – Twitter username
twitterPassword – Twitter password

HOW SCRIPT OPERATES

The script checks the content of a remote web page at a regular interval (determined by com.semifluid.boodle.plist). The web page should return “0” (All clear), “1” (Stolen), “2” (All clear, reset time stamp), or “3” (Stolen, reset time stamp). If the content is “0” or “2”, the script will send a Twitter update (if trackLocation is “1”) and quit. If the webpage returns “1” or “3”, the script assumes the phone is stolen and begins its work. In addition, if the webpage returns “2” or “3”, the script will also delete the time stamp file so that a full update will be emailed the next time the phone is marked as stolen.

When a phone is marked as stolen, the application will:
1. Estimate the location of the device using findme-muchbetter and save the information to a file
2. Use sqlite3 to export call history to a file
3. Use sqlite3 to export sms history to a file
4. Copy Safari’s web history plist file to a file
5. Email all of the database files to the $toEmail address
6. Check for photos taken with the camera since the last time the script ran
7. Resizes any new photos, archives them, and sends them to the $toEmail address

A snapshot of my social network on Facebook.  Red circles are girls, Blue circles are boys, and Black circles are undefined (i.e., the individual’s privacy settings disallow 3rd party information acquisition)